9x9 Everest 2012.txt

Order 3: digits 9; houses 27, cells 81.

Grid.grid1: initial copying

pending={a1, b3, b4, c2, c5, c7, d2, d6, e5, e6, e7, f4, f8, g3, g8, g9, h3, h4, h8, i2, i7}

deduce.grid1: naked-singles

deduce.grid1: hidden-singles

deduce.grid1: naked-pairs

two's heap=h7 {3|9}.

grid1
1 2 3 4 5 6 7 8 9
a 8
12 
4 6
   
 2 
456
  9
 23
4  
7  
123
 5 
7  
123
4  
   
1 3
 56
  9
   
45 
7 9
1 3
456
7 9
b
12 
45 
  9
12 
4  
   
3 6
12 
 5 
78 
12 
4  
 8 
1  
 5 
 89
   
45 
789
1  
45 
7 9
c
1  
456
   
7
   
456
   
  3
4  
 8 
9
1 3
4  
 8 
2
   
45 
 8 
1 3
456
   
d
123
4 6
  9
5
 2 
4 6
  9
 23
   
 89
 23
  6
 8 
7
1  
  6
 89
 2 
4  
 89
12 
4 6
  9
e
123
  6
  9
123
  6
 8 
 2 
  6
  9
 23
   
 89
4 5 7
 2 
   
 89
12 
  6
  9
f
 2 
4 6
7 9
 2 
4 6
 8 
 2 
4 6
7 9
1
 2 
  6
 8 
 2 
  6
 89
   
 56
 89
3
 2 
456
  9
g
 23
45 
7  
 23
4  
   
1
 23
4  
7 9
 23
   
7  
 23
4  
  9
  3
 5 
  9
6 8
h
 23
4 6
7  
 23
4 6
   
8 5
 23
  6
7  
 23
4 6
  9
  3
   
  9
1
 23
   
7 9
i
 23
 56
7  
9
 2 
 56
7  
 23
   
78 
123
  6
78 
123
  6
 8 
4
 2 
 5 
7  
 23
 5 
7  

backtrack.grid1 → grid2: h7 guess 3 ∈ {3|9}

pending={h7}

deduce.grid2: naked-singles

deduce.grid2: hidden-singles

deduce.grid2: naked-pairs

two's heap=g7 {5|9}.

grid2
1 2 3 4 5 6 7 8 9
a 8
12 
4 6
   
 2 
456
  9
 23
4  
7  
123
 5 
7  
123
4  
   
1  
 56
  9
   
45 
7 9
1 3
456
7 9
b
12 
45 
  9
12 
4  
   
3 6
12 
 5 
78 
12 
4  
 8 
1  
 5 
 89
   
45 
789
1  
45 
7 9
c
1  
456
   
7
   
456
   
  3
4  
 8 
9
1 3
4  
 8 
2
   
45 
 8 
1 3
456
   
d
123
4 6
  9
5
 2 
4 6
  9
 23
   
 89
 23
  6
 8 
7
1  
  6
 89
 2 
4  
 89
12 
4 6
  9
e
123
  6
  9
123
  6
 8 
 2 
  6
  9
 23
   
 89
4 5 7
 2 
   
 89
12 
  6
  9
f
 2 
4 6
7 9
 2 
4 6
 8 
 2 
4 6
7 9
1
 2 
  6
 8 
 2 
  6
 89
   
 56
 89
3
 2 
456
  9
g
 23
45 
7  
 23
4  
   
1
 23
4  
7 9
 23
   
7  
 23
4  
  9
   
 5 
  9
6 8
h
 2 
4 6
7  
 2 
4 6
   
8 5
 2 
  6
7  
 2 
4 6
  9
3 1
 2 
   
7 9
i
 23
 56
7  
9
 2 
 56
7  
 23
   
78 
123
  6
78 
123
  6
 8 
4
 2 
 5 
7  
 2 
 5 
7  

backtrack.grid2 → grid3: g7 guess 5 ∈ {5|9}

pending={g7}

deduce.grid3: naked-singles

deduce.grid3: hidden-singles

deduce.grid3.rowf. f9 is 5 by hidden-single.

pending={f9}

deduce.grid3: naked-singles

deduce.grid3: hidden-singles

deduce.grid3.box9. h9 is 9 by hidden-single.

pending={h9}

deduce.grid3: naked-singles

deduce.grid3: hidden-singles

deduce.grid3: naked-pairs

two's heap=i8 {2|7}, i9 {2|7}.

Naked-pair {2|7} in cells {i8, i9} contained within {rowi, box9}, updating cells {i1, i3, i4, i5, i6}:

grid3
1 2 3 4 5 6 7 8 9
a 8
12 
4 6
   
 2 
456
  9
 23
4  
7  
123
 5 
7  
123
4  
   
1  
  6
  9
   
45 
7 9
1 3
4 6
7  
b
12 
45 
  9
12 
4  
   
3 6
12 
 5 
78 
12 
4  
 8 
1  
   
 89
   
45 
789
1  
4  
7  
c
1  
456
   
7
   
456
   
  3
4  
 8 
9
1 3
4  
 8 
2
   
45 
 8 
1 3
4 6
   
d
123
4 6
  9
5
 2 
4 6
  9
 23
   
 89
 23
  6
 8 
7
1  
  6
 89
 2 
4  
 89
12 
4 6
   
e
123
  6
  9
123
  6
 8 
 2 
  6
  9
 23
   
 89
4 5 7
 2 
   
 89
12 
  6
   
f
 2 
4 6
7 9
 2 
4 6
 8 
 2 
4 6
7 9
1
 2 
  6
 8 
 2 
  6
 89
   
  6
 89
3 5
g
 23
4  
7  
 23
4  
   
1
 23
4  
7 9
 23
   
7  
 23
4  
  9
5 6 8
h
 2 
4 6
7  
 2 
4 6
   
8 5
 2 
  6
7  
 2 
4 6
   
3 1 9
i
  3
 56
   
9
   
 56
   
  3
   
 8 
1 3
  6
 8 
1 3
  6
 8 
4
 2 
   
7  
 2 
   
7  

backtrack.grid3 → grid4: i3 guess 5 ∈ {5|6}

pending={i3}

deduce.grid4: naked-singles

deduce.grid4: hidden-singles

deduce.grid4.col3. f3 is 7 by hidden-single.

pending={f3}

deduce.grid4: naked-singles

deduce.grid4: hidden-singles

deduce.grid4: naked-pairs

two's heap=i1 {3|6}, c3 {4|6}, i4 {3|8}, i8 {2|7}, i9 {2|7}.

Naked-pair {2|7} in cells {i8, i9} contained within {rowi, box9}, updating cells {i1, i4, i5, i6}:

grid4
1 2 3 4 5 6 7 8 9
a 8
12 
4 6
   
 2 
4 6
  9
 23
4  
7  
123
 5 
7  
123
4  
   
1  
  6
  9
   
45 
7 9
1 3
4 6
7  
b
12 
45 
  9
12 
4  
   
3 6
12 
 5 
78 
12 
4  
 8 
1  
   
 89
   
45 
789
1  
4  
7  
c
1  
456
   
7
   
4 6
   
  3
4  
 8 
9
1 3
4  
 8 
2
   
45 
 8 
1 3
4 6
   
d
123
4 6
  9
5
 2 
4 6
  9
 23
   
 89
 23
  6
 8 
7
1  
  6
 89
 2 
4  
 89
12 
4 6
   
e
123
  6
  9
123
  6
 8 
 2 
  6
  9
 23
   
 89
4 5 7
 2 
   
 89
12 
  6
   
f
 2 
4 6
  9
 2 
4 6
 8 
7 1
 2 
  6
 8 
 2 
  6
 89
   
  6
 89
3 5
g
 23
4  
7  
 23
4  
   
1
 23
4  
7 9
 23
   
7  
 23
4  
  9
5 6 8
h
 2 
4 6
7  
 2 
4 6
   
8 5
 2 
  6
7  
 2 
4 6
   
3 1 9
i
  3
  6
   
9 5
  3
   
 8 
1 3
  6
 8 
1 3
  6
 8 
4
 2 
   
7  
 2 
   
7  

backtrack.grid4 → grid5: c3 guess 4 ∈ {4|6}

pending={c3}

deduce.grid5: naked-singles

deduce.grid5: hidden-singles

deduce.grid5: naked-pairs

two's heap=b2 {1|2}, i1 {3|6}, i8 {2|7}, c4 {3|8}, i4 {3|8}, c8 {5|8}, i9 {2|7}.

Naked-pair {2|7} in cells {i8, i9} contained within {rowi, box9}, updating cells {i1, i4, i5, i6}:

Naked-pair {3|8} in cells {c4, i4} contained within {col4}, updating cells {a4, d4, e4, g4}:

grid5
1 2 3 4 5 6 7 8 9
a 8
12 
  6
   
 2 
  6
  9
 2 
4  
7  
123
 5 
7  
123
4  
   
1  
  6
  9
   
45 
7 9
1 3
4 6
7  
b
12 
 5 
  9
12 
   
   
3 6
12 
 5 
78 
12 
4  
 8 
1  
   
 89
   
45 
789
1  
4  
7  
c
1  
 56
   
7 4
  3
   
 8 
9
1 3
   
 8 
2
   
 5 
 8 
1 3
  6
   
d
123
4 6
  9
5
 2 
  6
  9
 2 
   
  9
 23
  6
 8 
7
1  
  6
 89
 2 
4  
 89
12 
4 6
   
e
123
  6
  9
123
  6
 8 
 2 
  6
  9
 2 
   
  9
4 5 7
 2 
   
 89
12 
  6
   
f
 2 
4 6
  9
 2 
4 6
 8 
7 1
 2 
  6
 8 
 2 
  6
 89
   
  6
 89
3 5
g
 23
4  
7  
 23
4  
   
1
 2 
4  
7 9
 23
   
7  
 23
4  
  9
5 6 8
h
 2 
4 6
7  
 2 
4 6
   
8 5
 2 
  6
7  
 2 
4 6
   
3 1 9
i
  3
  6
   
9 5
  3
   
 8 
1 3
  6
 8 
1 3
  6
 8 
4
 2 
   
7  
 2 
   
7  

backtrack.grid5 → grid6: b2 guess 1 ∈ {1|2}

pending={b2}

deduce.grid6: naked-singles

deduce.grid6: hidden-singles

deduce.grid6.box5. d5 is 3 by hidden-single.

pending={d5}

deduce.grid6: naked-singles

deduce.grid6: hidden-singles

deduce.grid6: naked-pairs

two's heap=a2 {2|6}, i1 {3|6}, i8 {2|7}, g5 {2|7}, c1 {5|6}, i9 {2|7}, d4 {2|9}, b7 {8|9}, e4 {2|9}, c4 {3|8}, i4 {3|8}, c8 {5|8}, b9 {4|7}.

Naked-pair {2|7} in cells {g5, i8, i9} contained within {rowi, box9}, updating cells {i1, i4, i5, i6}:

Naked-pair {3|8} in cells {c4, i4} contained within {col4}, updating cells {a4, d4, e4, g4}:

Naked-pair {2|9} in cells {d4, e4} contained within {col4, box5}, updating cells {a4, c4, f5, f6, g4, i4}:

grid6
1 2 3 4 5 6 7 8 9
a 8
 2 
  6
   
 2 
  6
  9
   
4  
7  
12 
 5 
7  
123
4  
   
1  
  6
  9
   
45 
7 9
1 3
4 6
7  
b
 2 
 5 
  9
1 3 6
 2 
 5 
78 
 2 
4  
 8 
   
   
 89
   
45 
789
   
4  
7  
c
   
 56
   
7 4
  3
   
 8 
9
1 3
   
 8 
2
   
 5 
 8 
1 3
  6
   
d
12 
4 6
  9
5
 2 
  6
  9
 2 
   
  9
3 7
1  
  6
 89
 2 
4  
 89
12 
4 6
   
e
123
  6
  9
 23
  6
 8 
 2 
  6
  9
 2 
   
  9
4 5 7
 2 
   
 89
12 
  6
   
f
 2 
4 6
  9
 2 
4 6
 8 
7 1
   
  6
 8 
   
  6
 8 
   
  6
 89
3 5
g
 23
4  
7  
 23
4  
   
1
   
4  
7  
 2 
   
7  
 23
4  
  9
5 6 8
h
 2 
4 6
7  
 2 
4 6
   
8 5
 2 
  6
7  
 2 
4 6
   
3 1 9
i
  3
  6
   
9 5
  3
   
 8 
1  
  6
 8 
1 3
  6
 8 
4
 2 
   
7  
 2 
   
7  

backtrack.grid6 → grid7: a2 guess 2 ∈ {2|6}

pending={a2}

deduce.grid7: naked-singles

deduce.grid7: hidden-singles

deduce.grid7.rowf. f1 is 2 by hidden-single.

pending={f1}

deduce.grid7: naked-singles

deduce.grid7: hidden-singles

deduce.grid7.rowf. f2 is 4 by hidden-single.

deduce.grid7.rowf. f7 is 9 by hidden-single.

pending={f2, f7}

deduce.grid7: naked-singles

grid7 didn't work: naked-singles ran out of candidates.

…backtrack.grid6 again

backtrack.grid6 → grid8: a2 guess 6 ∈ {2|6}

pending={a2}

deduce.grid8: naked-singles

deduce.grid8: hidden-singles

deduce.grid8.rowa. a9 is 3 by hidden-single.

pending={a9}

deduce.grid8: naked-singles

deduce.grid8: hidden-singles

deduce.grid8.rowd. d7 is 8 by hidden-single.

pending={d7}

deduce.grid8: naked-singles

grid8 didn't work: naked-singles ran out of candidates.

…backtrack.grid6 again

grid6 didn't work: exhaustive search revealed no solution.

…backtrack.grid5 again

backtrack.grid5 → grid9: b2 guess 2 ∈ {1|2}

pending={b2}

deduce.grid9: naked-singles

deduce.grid9: hidden-singles

deduce.grid9.box5. d5 is 3 by hidden-single.

pending={d5}

deduce.grid9: naked-singles

deduce.grid9: hidden-singles

deduce.grid9: naked-pairs

two's heap=g2 {3|4}, i1 {3|6}, a2 {1|6}, g5 {2|7}, h2 {4|6}, i8 {2|7}, c4 {3|8}, a3 {6|9}, c8 {5|8}, d4 {2|9}, i4 {3|8}, e4 {2|9}, i9 {2|7}.

Naked-pair {2|7} in cells {g5, i8, i9} contained within {rowi, box9}, updating cells {i1, i4, i5, i6}:

Naked-pair {3|8} in cells {c4, i4} contained within {col4}, updating cells {a4, d4, e4, g4}:

Naked-pair {2|9} in cells {d4, e4} contained within {col4, box5}, updating cells {a4, c4, f5, f6, g4, i4}:

grid9
1 2 3 4 5 6 7 8 9
a 8
1  
  6
   
   
  6
  9
   
4  
7  
12 
 5 
7  
123
4  
   
1  
  6
  9
   
45 
7 9
1 3
4 6
7  
b
1  
 5 
  9
2 3 6
1  
 5 
78 
1  
4  
 8 
1  
   
 89
   
45 
789
1  
4  
7  
c
1  
 56
   
7 4
  3
   
 8 
9
1 3
   
 8 
2
   
 5 
 8 
1 3
  6
   
d
12 
4 6
  9
5
 2 
  6
  9
 2 
   
  9
3 7
1  
  6
 89
 2 
4  
 89
12 
4 6
   
e
123
  6
  9
1 3
  6
 8 
 2 
  6
  9
 2 
   
  9
4 5 7
 2 
   
 89
12 
  6
   
f
 2 
4 6
  9
   
4 6
 8 
7 1
   
  6
 8 
   
  6
 8 
   
  6
 89
3 5
g
 23
4  
7  
  3
4  
   
1
   
4  
7  
 2 
   
7  
 23
4  
  9
5 6 8
h
 2 
4 6
7  
   
4 6
   
8 5
 2 
  6
7  
 2 
4 6
   
3 1 9
i
  3
  6
   
9 5
  3
   
 8 
1  
  6
 8 
1 3
  6
 8 
4
 2 
   
7  
 2 
   
7  

backtrack.grid9 → grid10: a2 guess 1 ∈ {1|6}

pending={a2}

deduce.grid10: naked-singles

deduce.grid10: hidden-singles

deduce.grid10.rowf. f1 is 2 by hidden-single.

pending={f1}

deduce.grid10: naked-singles

deduce.grid10: hidden-singles

deduce.grid10.rowf. f2 is 4 by hidden-single.

deduce.grid10.rowf. f7 is 9 by hidden-single.

pending={f2, f7}

deduce.grid10: naked-singles

grid10 didn't work: naked-singles ran out of candidates.

…backtrack.grid9 again

backtrack.grid9 → grid11: a2 guess 6 ∈ {1|6}

pending={a2}

deduce.grid11: naked-singles

grid11 didn't work: naked-singles ran out of candidates.

…backtrack.grid9 again

grid9 didn't work: exhaustive search revealed no solution.

…backtrack.grid5 again

grid5 didn't work: exhaustive search revealed no solution.

…backtrack.grid4 again

backtrack.grid4 → grid12: c3 guess 6 ∈ {4|6}

pending={c3}

deduce.grid12: naked-singles

deduce.grid12: hidden-singles

deduce.grid12: naked-pairs

two's heap=i1 {3|6}, i8 {2|7}, i4 {3|8}, e3 {2|9}, i9 {2|7}.

Naked-pair {2|7} in cells {i8, i9} contained within {rowi, box9}, updating cells {i1, i4, i5, i6}:

grid12
1 2 3 4 5 6 7 8 9
a 8
12 
4  
   
 2 
4  
  9
 23
4  
7  
123
 5 
7  
123
4  
   
1  
  6
  9
   
45 
7 9
1 3
4 6
7  
b
12 
45 
  9
12 
4  
   
3 6
12 
 5 
78 
12 
4  
 8 
1  
   
 89
   
45 
789
1  
4  
7  
c
1  
45 
   
7 6
  3
4  
 8 
9
1 3
4  
 8 
2
   
45 
 8 
1 3
4  
   
d
123
4 6
  9
5
 2 
4  
  9
 23
   
 89
 23
  6
 8 
7
1  
  6
 89
 2 
4  
 89
12 
4 6
   
e
123
  6
  9
123
  6
 8 
 2 
   
  9
 23
   
 89
4 5 7
 2 
   
 89
12 
  6
   
f
 2 
4 6
  9
 2 
4 6
 8 
7 1
 2 
  6
 8 
 2 
  6
 89
   
  6
 89
3 5
g
 23
4  
7  
 23
4  
   
1
 23
4  
7 9
 23
   
7  
 23
4  
  9
5 6 8
h
 2 
4 6
7  
 2 
4 6
   
8 5
 2 
  6
7  
 2 
4 6
   
3 1 9
i
  3
  6
   
9 5
  3
   
 8 
1 3
  6
 8 
1 3
  6
 8 
4
 2 
   
7  
 2 
   
7  

backtrack.grid12 → grid13: e3 guess 2 ∈ {2|9}

pending={e3}

deduce.grid13: naked-singles

deduce.grid13: hidden-singles

deduce.grid13: naked-pairs

two's heap=e9 {1|6}, i1 {3|6}, i8 {2|7}, i9 {2|7}, a3 {4|9}, e8 {8|9}, i4 {3|8}, d3 {4|9}.

Naked-pair {2|7} in cells {i8, i9} contained within {rowi, box9}, updating cells {i1, i4, i5, i6}:

grid13
1 2 3 4 5 6 7 8 9
a 8
12 
4  
   
   
4  
  9
 23
4  
7  
123
 5 
7  
123
4  
   
1  
  6
  9
   
45 
7 9
1 3
4 6
7  
b
12 
45 
  9
12 
4  
   
3 6
12 
 5 
78 
12 
4  
 8 
1  
   
 89
   
45 
789
1  
4  
7  
c
1  
45 
   
7 6
  3
4  
 8 
9
1 3
4  
 8 
2
   
45 
 8 
1 3
4  
   
d
1 3
4 6
  9
5
   
4  
  9
 23
   
 89
 23
  6
 8 
7
1  
  6
 89
 2 
4  
 89
12 
4 6
   
e
1 3
  6
  9
1 3
  6
 8 
2
  3
   
 89
4 5 7
   
   
 89
1  
  6
   
f
   
4 6
  9
   
4 6
 8 
7 1
 2 
  6
 8 
 2 
  6
 89
   
  6
 89
3 5
g
 23
4  
7  
 23
4  
   
1
 23
4  
7 9
 23
   
7  
 23
4  
  9
5 6 8
h
 2 
4 6
7  
 2 
4 6
   
8 5
 2 
  6
7  
 2 
4 6
   
3 1 9
i
  3
  6
   
9 5
  3
   
 8 
1 3
  6
 8 
1 3
  6
 8 
4
 2 
   
7  
 2 
   
7  

backtrack.grid13 → grid14: a3 guess 4 ∈ {4|9}

pending={a3}

deduce.grid14: naked-singles

deduce.grid14: hidden-singles

deduce.grid14.col1. b1 is 9 by hidden-single.

pending={b1}

deduce.grid14: naked-singles

deduce.grid14: hidden-singles

deduce.grid14.col1. c1 is 5 by hidden-single.

pending={c1}

deduce.grid14: naked-singles

deduce.grid14: hidden-singles

deduce.grid14: naked-pairs

two's heap=a2 {1|2}, b2 {1|2}, e9 {1|6}, i1 {3|6}, i8 {2|7}, b7 {1|8}, f1 {4|6}, c8 {4|8}, i4 {3|8}, e8 {8|9}, i9 {2|7}.

Naked-pair {1|2} in cells {a2, b2} contained within {col2, box1}, updating cells {e2, f2, g2, h2}:

Naked-pair {2|7} in cells {i8, i9} contained within {rowi, box9}, updating cells {i1, i4, i5, i6}:

grid14
1 2 3 4 5 6 7 8 9
a 8
12 
   
   
4
 23
   
7  
123
 5 
7  
123
   
   
1  
  6
  9
   
 5 
7 9
1 3
  6
7  
b 9
12 
   
   
3 6
12 
 5 
78 
12 
4  
 8 
1  
   
 8 
   
45 
78 
1  
4  
7  
c 5 7 6
  3
4  
 8 
9
1 3
4  
 8 
2
   
4  
 8 
1 3
4  
   
d
1 3
4 6
   
5 9
 23
   
 8 
 23
  6
 8 
7
1  
  6
 8 
 2 
4  
 8 
12 
4 6
   
e
1 3
  6
   
  3
  6
 8 
2
  3
   
 89
4 5 7
   
   
 89
1  
  6
   
f
   
4 6
   
   
4 6
 8 
7 1
 2 
  6
 8 
 2 
  6
 89
   
  6
 89
3 5
g
 23
4  
7  
  3
4  
   
1
 23
4  
7 9
 23
   
7  
 23
4  
  9
5 6 8
h
 2 
4 6
7  
   
4 6
   
8 5
 2 
  6
7  
 2 
4 6
   
3 1 9
i
  3
  6
   
9 5
  3
   
 8 
1 3
  6
 8 
1 3
  6
 8 
4
 2 
   
7  
 2 
   
7  

backtrack.grid14 → grid15: a2 guess 1 ∈ {1|2}

pending={a2}

deduce.grid15: naked-singles

deduce.grid15: hidden-singles

deduce.grid15: naked-pairs

two's heap=a6 {2|3}, g2 {3|4}, e9 {1|6}, h2 {4|6}, i1 {3|6}, i8 {2|7}, f1 {4|6}, a7 {6|9}, c8 {4|8}, e8 {8|9}, i4 {3|8}, b7 {1|8}, i9 {2|7}.

Naked-pair {2|7} in cells {i8, i9} contained within {rowi, box9}, updating cells {i1, i4, i5, i6}:

grid15
1 2 3 4 5 6 7 8 9
a 8 1 4
 23
   
7  
 23
 5 
7  
 23
   
   
   
  6
  9
   
 5 
7 9
  3
  6
7  
b 9 2 3 6
1  
 5 
78 
1  
4  
 8 
1  
   
 8 
   
45 
78 
1  
4  
7  
c 5 7 6
  3
4  
 8 
9
1 3
4  
 8 
2
   
4  
 8 
1 3
4  
   
d
1 3
4 6
   
5 9
 23
   
 8 
 23
  6
 8 
7
1  
  6
 8 
 2 
4  
 8 
12 
4 6
   
e
1 3
  6
   
  3
  6
 8 
2
  3
   
 89
4 5 7
   
   
 89
1  
  6
   
f
   
4 6
   
   
4 6
 8 
7 1
 2 
  6
 8 
 2 
  6
 89
   
  6
 89
3 5
g
 23
4  
7  
  3
4  
   
1
 23
4  
7 9
 23
   
7  
 23
4  
  9
5 6 8
h
 2 
4 6
7  
   
4 6
   
8 5
 2 
  6
7  
 2 
4 6
   
3 1 9
i
  3
  6
   
9 5
  3
   
 8 
1 3
  6
 8 
1 3
  6
 8 
4
 2 
   
7  
 2 
   
7  

backtrack.grid15 → grid16: a6 guess 2 ∈ {2|3}

pending={a6}

deduce.grid16: naked-singles

deduce.grid16: hidden-singles

deduce.grid16.rowf. f5 is 2 by hidden-single.

pending={f5}

deduce.grid16: naked-singles

deduce.grid16: hidden-singles

deduce.grid16.rowh. h1 is 2 by hidden-single.

pending={h1}

deduce.grid16: naked-singles

deduce.grid16: hidden-singles

deduce.grid16.rowg. g4 is 2 by hidden-single.

pending={g4}

deduce.grid16: naked-singles

deduce.grid16: hidden-singles

deduce.grid16.rowg. g6 is 9 by hidden-single.

pending={g6}

deduce.grid16: naked-singles

deduce.grid16: hidden-singles

deduce.grid16.rowf. f7 is 9 by hidden-single.

pending={f7}

deduce.grid16: naked-singles

grid16 didn't work: naked-singles ran out of candidates.

…backtrack.grid15 again

backtrack.grid15 → grid17: a6 guess 3 ∈ {2|3}

pending={a6}

deduce.grid17: naked-singles

deduce.grid17: hidden-singles

deduce.grid17.rowc. c9 is 3 by hidden-single.

pending={c9}

deduce.grid17: naked-singles

deduce.grid17: hidden-singles

deduce.grid17.rowc. c6 is 1 by hidden-single.

pending={c6}

deduce.grid17: naked-singles

deduce.grid17: hidden-singles

deduce.grid17.rowi. i5 is 1 by hidden-single.

pending={i5}

deduce.grid17: naked-singles

deduce.grid17: hidden-singles

deduce.grid17: naked-pairs

two's heap=g2 {3|4}, e9 {1|6}, i1 {3|6}, i8 {2|7}, f1 {4|6}, h2 {4|6}, i4 {3|8}, i9 {2|7}, a7 {6|9}, b6 {4|8}, a4 {2|7}, c4 {4|8}, a9 {6|7}, c8 {4|8}, i6 {6|8}, e8 {8|9}, b7 {1|8}.

Naked-pair {2|7} in cells {a4, i8, i9} contained within {rowi, box9}, updating cells {i1, i4, i6}:

Naked-pair {4|8} in cells {b6, c4, c8} contained within {rowc, box2}, updating cells {a4, a5, b5}:

grid17
1 2 3 4 5 6 7 8 9
a 8 1 4
 2 
   
7  
 2 
 5 
7  
3
   
  6
  9
   
 5 
7 9
   
  6
7  
b 9 2 3 6
   
 5 
7  
   
4  
 8 
1  
   
 8 
   
45 
78 
1  
4  
7  
c 5 7 6
   
4  
 8 
9 1 2
   
4  
 8 
3
d
1 3
4 6
   
5 9
 23
   
 8 
 23
  6
 8 
7
1  
  6
 8 
 2 
4  
 8 
12 
4 6
   
e
1 3
  6
   
  3
  6
 8 
2
  3
   
 89
4 5 7
   
   
 89
1  
  6
   
f
   
4 6
   
   
4 6
 8 
7 1
 2 
  6
 8 
 2 
  6
 89
   
  6
 89
3 5
g
 23
4  
7  
  3
4  
   
1
 23
4  
7 9
 23
   
7  
 2 
4  
  9
5 6 8
h
 2 
4 6
7  
   
4 6
   
8 5
 2 
  6
7  
 2 
4 6
   
3 1 9
i
  3
  6
   
9 5
  3
   
 8 
1
   
  6
 8 
4
 2 
   
7  
 2 
   
7  

backtrack.grid17 → grid18: a4 guess 2 ∈ {2|7}

pending={a4}

deduce.grid18: naked-singles

deduce.grid18: hidden-singles

deduce.grid18.col4. g4 is 7 by hidden-single.

pending={g4}

deduce.grid18: naked-singles

deduce.grid18: hidden-singles

deduce.grid18.rowg. g6 is 9 by hidden-single.

pending={g6}

deduce.grid18: naked-singles

deduce.grid18: hidden-singles

deduce.grid18.rowf. f7 is 9 by hidden-single.

pending={f7}

deduce.grid18: naked-singles

grid18 didn't work: naked-singles ran out of candidates.

…backtrack.grid17 again

backtrack.grid17 → grid19: a4 guess 7 ∈ {2|7}

pending={a4}

deduce.grid19: naked-singles

deduce.grid19: hidden-singles

deduce.grid19.rowb. b7 is 1 by hidden-single.

pending={b7}

deduce.grid19: naked-singles

deduce.grid19: hidden-singles

deduce.grid19.rowd. d1 is 1 by hidden-single.

pending={d1}

deduce.grid19: naked-singles

deduce.grid19: hidden-singles

grid19 didn't work: more than one hidden-candidate in cell 50.

…backtrack.grid17 again

grid17 didn't work: exhaustive search revealed no solution.

…backtrack.grid15 again

grid15 didn't work: exhaustive search revealed no solution.

…backtrack.grid14 again

backtrack.grid14 → grid20: a2 guess 2 ∈ {1|2}

pending={a2}

deduce.grid20: naked-singles

deduce.grid20: hidden-singles

deduce.grid20.rowa. a5 is 5 by hidden-single.

pending={a5}

deduce.grid20: naked-singles

deduce.grid20: hidden-singles

deduce.grid20.rowa. a4 is 7 by hidden-single.

pending={a4}

deduce.grid20: naked-singles

deduce.grid20: hidden-singles

deduce.grid20.rowe. e4 is 9 by hidden-single.

pending={e4}

deduce.grid20: naked-singles

deduce.grid20: hidden-singles

deduce.grid20.rowf. f6 is 2 by hidden-single.

deduce.grid20.rowf. f7 is 9 by hidden-single.

pending={f6, f7}

deduce.grid20: naked-singles

grid20 didn't work: naked-singles ran out of candidates.

…backtrack.grid14 again

grid14 didn't work: exhaustive search revealed no solution.

…backtrack.grid13 again

backtrack.grid13 → grid21: a3 guess 9 ∈ {4|9}

pending={a3}

deduce.grid21: naked-singles

deduce.grid21: hidden-singles

grid21 didn't work: rowf is not bijective.

…backtrack.grid13 again

grid13 didn't work: exhaustive search revealed no solution.

…backtrack.grid12 again

backtrack.grid12 → grid22: e3 guess 9 ∈ {2|9}

pending={e3}

deduce.grid22: naked-singles

deduce.grid22: hidden-singles

deduce.grid22.col1. b1 is 9 by hidden-single.

pending={b1}

deduce.grid22: naked-singles

deduce.grid22: hidden-singles

deduce.grid22.col1. c1 is 5 by hidden-single.

pending={c1}

deduce.grid22: naked-singles

deduce.grid22: hidden-singles

deduce.grid22: naked-pairs

two's heap=a3 {2|4}, d3 {2|4}, i1 {3|6}, i8 {2|7}, e8 {2|8}, c8 {4|8}, i4 {3|8}, b7 {1|8}, i9 {2|7}.

Naked-pair {2|7} in cells {i8, i9} contained within {rowi, box9}, updating cells {i1, i4, i5, i6}:

grid22
1 2 3 4 5 6 7 8 9
a 8
12 
4  
   
 2 
4  
   
 23
4  
7  
123
 5 
7  
123
4  
   
1  
  6
  9
   
45 
7 9
1 3
4 6
7  
b 9
12 
4  
   
3 6
12 
 5 
78 
12 
4  
 8 
1  
   
 8 
   
45 
78 
1  
4  
7  
c 5 7 6
  3
4  
 8 
9
1 3
4  
 8 
2
   
4  
 8 
1 3
4  
   
d
123
4 6
   
5
 2 
4  
   
 23
   
 89
 23
  6
 8 
7
1  
  6
 89
 2 
4  
 89
12 
4 6
   
e
123
  6
   
123
  6
 8 
9
 23
   
 8 
4 5 7
 2 
   
 8 
12 
  6
   
f
 2 
4 6
   
 2 
4 6
 8 
7 1
 2 
  6
 8 
 2 
  6
 89
   
  6
 89
3 5
g
 23
4  
7  
 23
4  
   
1
 23
4  
7 9
 23
   
7  
 23
4  
  9
5 6 8
h
 2 
4 6
7  
 2 
4 6
   
8 5
 2 
  6
7  
 2 
4 6
   
3 1 9
i
  3
  6
   
9 5
  3
   
 8 
1 3
  6
 8 
1 3
  6
 8 
4
 2 
   
7  
 2 
   
7  

backtrack.grid22 → grid23: a3 guess 2 ∈ {2|4}

pending={a3}

deduce.grid23: naked-singles

deduce.grid23: hidden-singles

grid23 didn't work: rowf is not bijective.

…backtrack.grid22 again

backtrack.grid22 → grid24: a3 guess 4 ∈ {2|4}

pending={a3}

deduce.grid24: naked-singles

deduce.grid24: hidden-singles

deduce.grid24: naked-pairs

two's heap=a2 {1|2}, b2 {1|2}, i1 {3|6}, i8 {2|7}, i9 {2|7}, b7 {1|8}, f1 {4|6}, c8 {4|8}, i4 {3|8}, e8 {2|8}.

Naked-pair {1|2} in cells {a2, b2} contained within {col2, box1}, updating cells {e2, f2, g2, h2}:

Naked-pair {2|7} in cells {i8, i9} contained within {rowi, box9}, updating cells {i1, i4, i5, i6}:

grid24
1 2 3 4 5 6 7 8 9
a 8
12 
   
   
4
 23
   
7  
123
 5 
7  
123
   
   
1  
  6
  9
   
 5 
7 9
1 3
  6
7  
b 9
12 
   
   
3 6
12 
 5 
78 
12 
4  
 8 
1  
   
 8 
   
45 
78 
1  
4  
7  
c 5 7 6
  3
4  
 8 
9
1 3
4  
 8 
2
   
4  
 8 
1 3
4  
   
d
1 3
4 6
   
5 2
  3
   
 89
  3
  6
 8 
7
1  
  6
 89
   
4  
 89
1  
4 6
   
e
1 3
  6
   
  3
  6
 8 
9
 23
   
 8 
4 5 7
 2 
   
 8 
12 
  6
   
f
   
4 6
   
   
4 6
 8 
7 1
 2 
  6
 8 
 2 
  6
 89
   
  6
 89
3 5
g
 23
4  
7  
  3
4  
   
1
 23
4  
7 9
 23
   
7  
 23
4  
  9
5 6 8
h
 2 
4 6
7  
   
4 6
   
8 5
 2 
  6
7  
 2 
4 6
   
3 1 9
i
  3
  6
   
9 5
  3
   
 8 
1 3
  6
 8 
1 3
  6
 8 
4
 2 
   
7  
 2 
   
7  

backtrack.grid24 → grid25: a2 guess 1 ∈ {1|2}

pending={a2}

deduce.grid25: naked-singles

deduce.grid25: hidden-singles

deduce.grid25: naked-pairs

two's heap=a6 {2|3}, i1 {3|6}, g2 {3|4}, h2 {4|6}, i8 {2|7}, i9 {2|7}, f1 {4|6}, a7 {6|9}, e8 {2|8}, c8 {4|8}, i4 {3|8}, b7 {1|8}.

Naked-pair {2|7} in cells {i8, i9} contained within {rowi, box9}, updating cells {i1, i4, i5, i6}:

grid25
1 2 3 4 5 6 7 8 9
a 8 1 4
 23
   
7  
 23
 5 
7  
 23
   
   
   
  6
  9
   
 5 
7 9
  3
  6
7  
b 9 2 3 6
1  
 5 
78 
1  
4  
 8 
1  
   
 8 
   
45 
78 
1  
4  
7  
c 5 7 6
  3
4  
 8 
9
1 3
4  
 8 
2
   
4  
 8 
1 3
4  
   
d
1 3
4 6
   
5 2
  3
   
 89
  3
  6
 8 
7
1  
  6
 89
   
4  
 89
1  
4 6
   
e
1 3
  6
   
  3
  6
 8 
9
 23
   
 8 
4 5 7
 2 
   
 8 
12 
  6
   
f
   
4 6
   
   
4 6
 8 
7 1
 2 
  6
 8 
 2 
  6
 89
   
  6
 89
3 5
g
 23
4  
7  
  3
4  
   
1
 23
4  
7 9
 23
   
7  
 23
4  
  9
5 6 8
h
 2 
4 6
7  
   
4 6
   
8 5
 2 
  6
7  
 2 
4 6
   
3 1 9
i
  3
  6
   
9 5
  3
   
 8 
1 3
  6
 8 
1 3
  6
 8 
4
 2 
   
7  
 2 
   
7  

backtrack.grid25 → grid26: a6 guess 2 ∈ {2|3}

pending={a6}

deduce.grid26: naked-singles

deduce.grid26: hidden-singles

deduce.grid26.rowf. f5 is 2 by hidden-single.

pending={f5}

deduce.grid26: naked-singles

deduce.grid26: hidden-singles

deduce.grid26.rowh. h1 is 2 by hidden-single.

pending={h1}

deduce.grid26: naked-singles

deduce.grid26: hidden-singles

deduce.grid26.rowg. g4 is 2 by hidden-single.

pending={g4}

deduce.grid26: naked-singles

deduce.grid26: hidden-singles

deduce.grid26.rowg. g6 is 9 by hidden-single.

pending={g6}

deduce.grid26: naked-singles

deduce.grid26: hidden-singles

deduce.grid26.rowf. f7 is 9 by hidden-single.

pending={f7}

deduce.grid26: naked-singles

deduce.grid26: hidden-singles

deduce.grid26.rowa. a8 is 9 by hidden-single.

pending={a8}

deduce.grid26: naked-singles

deduce.grid26: hidden-singles

deduce.grid26.rowa. a5 is 5 by hidden-single.

pending={a5}

deduce.grid26: naked-singles

deduce.grid26: hidden-singles

deduce.grid26.rowb. b8 is 5 by hidden-single.

pending={b8}

deduce.grid26: naked-singles

deduce.grid26: hidden-singles

deduce.grid26.rowd. d4 is 9 by hidden-single.

pending={d4}

deduce.grid26: naked-singles

deduce.grid26: hidden-singles

deduce.grid26.rowh. h5 is 7 by hidden-single.

pending={h5}

deduce.grid26: naked-singles

grid26 didn't work: naked-singles ran out of candidates.

…backtrack.grid25 again

backtrack.grid25 → grid27: a6 guess 3 ∈ {2|3}

pending={a6}

deduce.grid27: naked-singles

deduce.grid27: hidden-singles

deduce.grid27.rowc. c9 is 3 by hidden-single.

pending={c9}

deduce.grid27: naked-singles

deduce.grid27: hidden-singles

deduce.grid27.rowc. c6 is 1 by hidden-single.

pending={c6}

deduce.grid27: naked-singles

deduce.grid27: hidden-singles

deduce.grid27.rowi. i5 is 1 by hidden-single.

pending={i5}

deduce.grid27: naked-singles

deduce.grid27: hidden-singles

deduce.grid27: naked-pairs

two's heap=g2 {3|4}, f1 {4|6}, i1 {3|6}, i9 {2|7}, h2 {4|6}, a9 {6|7}, i8 {2|7}, b7 {1|8}, e8 {2|8}, b6 {4|8}, a4 {2|7}, c4 {4|8}, i4 {3|8}, i6 {6|8}, c8 {4|8}, a7 {6|9}.

Naked-pair {2|7} in cells {a4, i8, i9} contained within {rowi, box9}, updating cells {i1, i4, i6}:

Naked-pair {4|8} in cells {b6, c4, c8} contained within {rowc, box2}, updating cells {a4, a5, b5}:

grid27
1 2 3 4 5 6 7 8 9
a 8 1 4
 2 
   
7  
 2 
 5 
7  
3
   
  6
  9
   
 5 
7 9
   
  6
7  
b 9 2 3 6
   
 5 
7  
   
4  
 8 
1  
   
 8 
   
45 
78 
1  
4  
7  
c 5 7 6
   
4  
 8 
9 1 2
   
4  
 8 
3
d
1 3
4 6
   
5 2
  3
   
 89
  3
  6
 8 
7
1  
  6
 89
   
4  
 89
1  
4 6
   
e
1 3
  6
   
  3
  6
 8 
9
 23
   
 8 
4 5 7
 2 
   
 8 
12 
  6
   
f
   
4 6
   
   
4 6
 8 
7 1
 2 
  6
 8 
 2 
  6
 89
   
  6
 89
3 5
g
 23
4  
7  
  3
4  
   
1
 23
4  
7 9
 23
   
7  
 2 
4  
  9
5 6 8
h
 2 
4 6
7  
   
4 6
   
8 5
 2 
  6
7  
 2 
4 6
   
3 1 9
i
  3
  6
   
9 5
  3
   
 8 
1
   
  6
 8 
4
 2 
   
7  
 2 
   
7  

backtrack.grid27 → grid28: a4 guess 2 ∈ {2|7}

pending={a4}

deduce.grid28: naked-singles

deduce.grid28: hidden-singles

deduce.grid28.col4. g4 is 7 by hidden-single.

pending={g4}

deduce.grid28: naked-singles

deduce.grid28: hidden-singles

deduce.grid28.rowg. g6 is 9 by hidden-single.

pending={g6}

deduce.grid28: naked-singles

deduce.grid28: hidden-singles

deduce.grid28.rowf. f7 is 9 by hidden-single.

pending={f7}

deduce.grid28: naked-singles

deduce.grid28: hidden-singles

deduce.grid28.rowb. b8 is 5 by hidden-single.

pending={b8}

deduce.grid28: naked-singles

deduce.grid28: hidden-singles

deduce.grid28.rowd. d4 is 9 by hidden-single.

pending={d4}

deduce.grid28: naked-singles

deduce.grid28: hidden-singles

deduce.grid28.rowe. e8 is 2 by hidden-single.

pending={e8}

deduce.grid28: naked-singles

deduce.grid28: hidden-singles

deduce.grid28.rowh. h1 is 7 by hidden-single.

pending={h1}

deduce.grid28: naked-singles

deduce.grid28: hidden-singles

deduce.grid28.col1. g1 is 2 by hidden-single.

pending={g1}

deduce.grid28: naked-singles

grid28 didn't work: naked-singles ran out of candidates.

…backtrack.grid27 again

backtrack.grid27 → grid29: a4 guess 7 ∈ {2|7}

pending={a4}

deduce.grid29: naked-singles

deduce.grid29: hidden-singles

grid29 didn't work: more than one hidden-candidate in cell 50.

…backtrack.grid27 again

grid27 didn't work: exhaustive search revealed no solution.

…backtrack.grid25 again

grid25 didn't work: exhaustive search revealed no solution.

…backtrack.grid24 again

backtrack.grid24 → grid30: a2 guess 2 ∈ {1|2}

pending={a2}

deduce.grid30: naked-singles

deduce.grid30: hidden-singles

deduce.grid30.rowa. a5 is 5 by hidden-single.

pending={a5}

deduce.grid30: naked-singles

deduce.grid30: hidden-singles

deduce.grid30.rowa. a4 is 7 by hidden-single.

pending={a4}

deduce.grid30: naked-singles

deduce.grid30: hidden-singles

deduce.grid30.rowf. f6 is 2 by hidden-single.

pending={f6}

deduce.grid30: naked-singles

grid30 didn't work: naked-singles ran out of candidates.

…backtrack.grid24 again

grid24 didn't work: exhaustive search revealed no solution.

…backtrack.grid22 again

grid22 didn't work: exhaustive search revealed no solution.

…backtrack.grid12 again

grid12 didn't work: exhaustive search revealed no solution.

…backtrack.grid4 again

grid4 didn't work: exhaustive search revealed no solution.

…backtrack.grid3 again

backtrack.grid3 → grid31: i3 guess 6 ∈ {5|6}

pending={i3}

deduce.grid31: naked-singles

deduce.grid31: hidden-singles

deduce.grid31.rowi. i1 is 5 by hidden-single.

pending={i1}

deduce.grid31: naked-singles

deduce.grid31: hidden-singles

deduce.grid31.col3. f3 is 7 by hidden-single.

pending={f3}

deduce.grid31: naked-singles

deduce.grid31: hidden-singles

deduce.grid31: naked-pairs

two's heap=h2 {2|4}, i8 {2|7}, c3 {4|5}, e3 {2|9}, i4 {3|8}, i9 {2|7}.

Naked-pair {2|7} in cells {i8, i9} contained within {rowi, box9}, updating cells {i4, i5, i6}:

grid31
1 2 3 4 5 6 7 8 9
a 8
12 
4 6
   
 2 
45 
  9
 23
4  
7  
123
 5 
7  
123
4  
   
1  
  6
  9
   
45 
7 9
1 3
4 6
7  
b
12 
4  
  9
12 
4  
   
3 6
12 
 5 
78 
12 
4  
 8 
1  
   
 89
   
45 
789
1  
4  
7  
c
1  
4 6
   
7
   
45 
   
  3
4  
 8 
9
1 3
4  
 8 
2
   
45 
 8 
1 3
4 6
   
d
123
4 6
  9
5
 2 
4  
  9
 23
   
 89
 23
  6
 8 
7
1  
  6
 89
 2 
4  
 89
12 
4 6
   
e
123
  6
  9
123
  6
 8 
 2 
   
  9
 23
   
 89
4 5 7
 2 
   
 89
12 
  6
   
f
 2 
4 6
  9
 2 
4 6
 8 
7 1
 2 
  6
 8 
 2 
  6
 89
   
  6
 89
3 5
g
 23
4  
7  
 23
4  
   
1
 23
4  
7 9
 23
   
7  
 23
4  
  9
5 6 8
h
 2 
4  
7  
 2 
4  
   
8 5
 2 
  6
7  
 2 
4 6
   
3 1 9
i 5 9 6
  3
   
 8 
1 3
   
 8 
1 3
   
 8 
4
 2 
   
7  
 2 
   
7  

backtrack.grid31 → grid32: c3 guess 4 ∈ {4|5}

pending={c3}

deduce.grid32: naked-singles

deduce.grid32: hidden-singles

deduce.grid32.rowc. c8 is 5 by hidden-single.

pending={c8}

deduce.grid32: naked-singles

deduce.grid32: hidden-singles

deduce.grid32.rowb. b5 is 5 by hidden-single.

pending={b5}

deduce.grid32: naked-singles

deduce.grid32: hidden-singles

deduce.grid32.rowa. a3 is 5 by hidden-single.

pending={a3}

deduce.grid32: naked-singles

deduce.grid32: hidden-singles

deduce.grid32.box1. b1 is 9 by hidden-single.

pending={b1}

deduce.grid32: naked-singles

deduce.grid32: hidden-singles

deduce.grid32: naked-pairs

two's heap=b2 {1|2}, i8 {2|7}, h2 {2|4}, b7 {1|8}, i9 {2|7}, e3 {2|9}, c1 {1|6}, i4 {3|8}, c4 {3|8}, d3 {2|9}.

Naked-pair {2|7} in cells {i8, i9} contained within {rowi, box9}, updating cells {i4, i5, i6}:

Naked-pair {3|8} in cells {c4, i4} contained within {col4}, updating cells {a4, d4, e4, g4}:

Naked-pair {2|9} in cells {d3, e3} contained within {col3, box4}, updating cells {d1, e1, e2, f1, f2}:

grid32
1 2 3 4 5 6 7 8 9
a 8
12 
  6
   
5
 2 
4  
7  
123
   
7  
123
4  
   
1  
  6
  9
   
4  
7 9
1 3
4 6
7  
b 9
12 
   
   
3 6 5
12 
4  
 8 
1  
   
 8 
   
4  
78 
1  
4  
7  
c
1  
  6
   
7 4
  3
   
 8 
9
1 3
   
 8 
2 5
1 3
  6
   
d
1 3
4 6
   
5
 2 
   
  9
 2 
   
  9
 23
  6
 8 
7
1  
  6
 89
 2 
4  
 89
12 
4 6
   
e
1 3
  6
   
1 3
  6
 8 
 2 
   
  9
 2 
   
  9
4 5 7
 2 
   
 89
12 
  6
   
f
   
4 6
   
   
4 6
 8 
7 1
 2 
  6
 8 
 2 
  6
 89
   
  6
 89
3 5
g
 23
4  
7  
 23
4  
   
1
 2 
4  
7 9
 23
   
7  
 23
4  
  9
5 6 8
h
 2 
4  
7  
 2 
4  
   
8 5
 2 
  6
7  
 2 
4 6
   
3 1 9
i 5 9 6
  3
   
 8 
1 3
   
 8 
1 3
   
 8 
4
 2 
   
7  
 2 
   
7  

backtrack.grid32 → grid33: b2 guess 1 ∈ {1|2}

pending={b2}

deduce.grid33: naked-singles

deduce.grid33: hidden-singles

deduce.grid33.rowb. b6 is 2 by hidden-single.

pending={b6}

deduce.grid33: naked-singles

deduce.grid33: hidden-singles

deduce.grid33.rowe. e1 is 3 by hidden-single.

pending={e1}

deduce.grid33: naked-singles

deduce.grid33: hidden-singles

deduce.grid33.rowd. d5 is 3 by hidden-single.

pending={d5}

deduce.grid33: naked-singles

deduce.grid33: hidden-singles

deduce.grid33.rowd. d8 is 8 by hidden-single.

pending={d8}

deduce.grid33: naked-singles

deduce.grid33: hidden-singles

deduce.grid33.rowd. d9 is 4 by hidden-single.

pending={d9}

deduce.grid33: naked-singles

grid33 didn't work: naked-singles ran out of candidates.

…backtrack.grid32 again

backtrack.grid32 → grid34: b2 guess 2 ∈ {1|2}

pending={b2}

deduce.grid34: naked-singles

deduce.grid34: hidden-singles

deduce.grid34.rowe. e1 is 3 by hidden-single.

pending={e1}

deduce.grid34: naked-singles

deduce.grid34: hidden-singles

deduce.grid34.rowd. d5 is 3 by hidden-single.

pending={d5}

deduce.grid34: naked-singles

deduce.grid34: hidden-singles

deduce.grid34.rowf. f1 is 4 by hidden-single.

pending={f1}

deduce.grid34: naked-singles

deduce.grid34: hidden-singles

deduce.grid34: naked-pairs

two's heap=a2 {1|6}, d1 {1|6}, c1 {1|6}, i8 {2|7}, g1 {2|7}, g5 {2|7}, h6 {2|6}, i5 {1|8}, i9 {2|7}, f2 {6|8}, b7 {1|8}, d3 {2|9}, h1 {2|7}, d4 {2|9}, i4 {3|8}, e3 {2|9}, c4 {3|8}, e4 {2|9}.

Naked-pair {1|6} in cells {a2, c1, d1} contained within {col1, box1}, updating cells {g1, h1}:

Naked-pair {2|7} in cells {g1, g5, h1, i8, i9} contained within {rowg, rowi, col1, box7, box9}, updating cells {c1, d1, g4, g6, i4, i5, i6}:

Naked-pair {3|8} in cells {c4, i4} contained within {col4}, updating cells {a4, d4, e4, g4}:

Naked-pair {2|9} in cells {d3, d4, e3, e4} contained within {rowd, rowe, col3, col4, box4, box5}, updating cells {a4, c4, d1, d7, d8, d9, e2, e8, e9, f2, f5, f6, g4, i4}:

pending={e8, g4}

deduce.grid34: naked-singles

deduce.grid34: hidden-singles

grid34 didn't work: rowd is not bijective.

…backtrack.grid32 again

grid32 didn't work: exhaustive search revealed no solution.

…backtrack.grid31 again

backtrack.grid31 → grid35: c3 guess 5 ∈ {4|5}

pending={c3}

deduce.grid35: naked-singles

deduce.grid35: hidden-singles

deduce.grid35: naked-pairs

two's heap=h2 {2|4}, i8 {2|7}, i9 {2|7}, e3 {2|9}, i4 {3|8}, c8 {4|8}.

Naked-pair {2|7} in cells {i8, i9} contained within {rowi, box9}, updating cells {i4, i5, i6}:

grid35
1 2 3 4 5 6 7 8 9
a 8
12 
4 6
   
 2 
4  
  9
 23
4  
7  
123
 5 
7  
123
4  
   
1  
  6
  9
   
45 
7 9
1 3
4 6
7  
b
12 
4  
  9
12 
4  
   
3 6
12 
 5 
78 
12 
4  
 8 
1  
   
 89
   
45 
789
1  
4  
7  
c
1  
4 6
   
7 5
  3
4  
 8 
9
1 3
4  
 8 
2
   
4  
 8 
1 3
4 6
   
d
123
4 6
  9
5
 2 
4  
  9
 23
   
 89
 23
  6
 8 
7
1  
  6
 89
 2 
4  
 89
12 
4 6
   
e
123
  6
  9
123
  6
 8 
 2 
   
  9
 23
   
 89
4 5 7
 2 
   
 89
12 
  6
   
f
 2 
4 6
  9
 2 
4 6
 8 
7 1
 2 
  6
 8 
 2 
  6
 89
   
  6
 89
3 5
g
 23
4  
7  
 23
4  
   
1
 23
4  
7 9
 23
   
7  
 23
4  
  9
5 6 8
h
 2 
4  
7  
 2 
4  
   
8 5
 2 
  6
7  
 2 
4 6
   
3 1 9
i 5 9 6
  3
   
 8 
1 3
   
 8 
1 3
   
 8 
4
 2 
   
7  
 2 
   
7  

backtrack.grid35 → grid36: c8 guess 4 ∈ {4|8}

pending={c8}

deduce.grid36: naked-singles

deduce.grid36: hidden-singles

deduce.grid36.col9. d9 is 4 by hidden-single.

pending={d9}

deduce.grid36: naked-singles

deduce.grid36: hidden-singles

deduce.grid36.col3. a3 is 4 by hidden-single.

pending={a3}

deduce.grid36: naked-singles

deduce.grid36: hidden-singles

deduce.grid36.rowb. b6 is 4 by hidden-single.

pending={b6}

deduce.grid36: naked-singles

deduce.grid36: hidden-singles

deduce.grid36.col4. g4 is 4 by hidden-single.

pending={g4}

deduce.grid36: naked-singles

deduce.grid36: hidden-singles

deduce.grid36.rowg. g6 is 9 by hidden-single.

pending={g6}

deduce.grid36: naked-singles

deduce.grid36: hidden-singles

deduce.grid36.col4. a4 is 7 by hidden-single.

pending={a4}

deduce.grid36: naked-singles

deduce.grid36: hidden-singles

deduce.grid36.box1. b1 is 9 by hidden-single.

pending={b1}

deduce.grid36: naked-singles

deduce.grid36: hidden-singles

deduce.grid36.rowf. f7 is 9 by hidden-single.

pending={f7}

deduce.grid36: naked-singles

deduce.grid36: hidden-singles

deduce.grid36.rowa. a8 is 9 by hidden-single.

pending={a8}

deduce.grid36: naked-singles

deduce.grid36: hidden-singles

deduce.grid36.rowa. a5 is 5 by hidden-single.

pending={a5}

deduce.grid36: naked-singles

deduce.grid36: hidden-singles

deduce.grid36.rowb. b8 is 5 by hidden-single.

pending={b8}

deduce.grid36: naked-singles

deduce.grid36: hidden-singles

deduce.grid36.rowb. b9 is 7 by hidden-single.

pending={b9}

deduce.grid36: naked-singles

deduce.grid36: hidden-singles

deduce.grid36.box3. b7 is 8 by hidden-single.

pending={b7}

deduce.grid36: naked-singles

deduce.grid36: hidden-singles

deduce.grid36: naked-pairs

two's heap=b2 {1|2}, a7 {1|6}, b5 {1|2}, c1 {1|6}, e9 {1|6}, g2 {2|3}, d7 {1|6}, d8 {2|8}, e3 {2|9}, c4 {3|8}, e8 {2|8}, d3 {2|9}, h2 {2|4}, h6 {2|6}, i4 {3|8}.

Naked-pair {1|6} in cells {a7, c1, d7, e9} contained within {col7, box6}, updating cells {d8, e8}:

Naked-pair {2|8} in cells {d8, e8} contained within {col8, box6}, updating cells {d7, e9}:

Naked-pair {3|8} in cells {c4, i4} contained within {col4}, updating cells {d4, e4}:

Naked-pair {2|9} in cells {d3, e3} contained within {col3, box4}, updating cells {d1, e1, e2, f1, f2}:

grid36
1 2 3 4 5 6 7 8 9
a 8
12 
  6
   
4 7 5
123
   
   
1  
  6
   
9
1 3
  6
   
b 9
12 
   
   
3 6
12 
   
   
4 8 5 7
c
1  
  6
   
7 5
  3
   
 8 
9
1 3
   
 8 
2 4
1 3
  6
   
d
1 3
  6
   
5
 2 
   
  9
 2 
   
  9
 23
  6
 8 
7
1  
  6
   
 2 
   
 8 
4
e
1 3
  6
   
1 3
  6
 8 
 2 
   
  9
 2 
   
  9
4 5 7
 2 
   
 8 
1  
  6
   
f
   
4 6
   
   
4 6
 8 
7 1
 2 
  6
 8 
 2 
  6
 8 
9 3 5
g
 23
   
7  
 23
   
   
1 4
 23
   
7  
9 5 6 8
h
 2 
4  
7  
 2 
4  
   
8 5
 2 
  6
7  
 2 
  6
   
3 1 9
i 5 9 6
  3
   
 8 
1 3
   
 8 
1 3
   
 8 
4 7 2

backtrack.grid36 → grid37: a7 guess 1 ∈ {1|6}

pending={a7}

deduce.grid37: naked-singles

deduce.grid37: hidden-singles

deduce.grid37.rowd. d1 is 1 by hidden-single.

pending={d1}

deduce.grid37: naked-singles

grid37 didn't work: naked-singles ran out of candidates.

…backtrack.grid36 again

backtrack.grid36 → grid38: a7 guess 6 ∈ {1|6}

pending={a7}

deduce.grid38: naked-singles

deduce.grid38: hidden-singles

deduce.grid38.rowc. c1 is 6 by hidden-single.

pending={c1}

deduce.grid38: naked-singles

grid38 didn't work: naked-singles ran out of candidates.

…backtrack.grid36 again

grid36 didn't work: exhaustive search revealed no solution.

…backtrack.grid35 again

backtrack.grid35 → grid39: c8 guess 8 ∈ {4|8}

pending={c8}

deduce.grid39: naked-singles

deduce.grid39: hidden-singles

deduce.grid39: naked-pairs

two's heap=h2 {2|4}, c4 {3|4}, i8 {2|7}, i9 {2|7}, b7 {1|9}, e3 {2|9}, i4 {3|8}, e8 {2|9}.

Naked-pair {2|7} in cells {i8, i9} contained within {rowi, box9}, updating cells {i4, i5, i6}:

Naked-pair {2|9} in cells {e3, e8} contained within {rowe}, updating cells {e1, e2, e4, e9}:

grid39
1 2 3 4 5 6 7 8 9
a 8
12 
4 6
   
 2 
4  
  9
 23
4  
7  
123
 5 
7  
123
4  
   
1  
  6
  9
   
45 
7 9
1 3
4 6
7  
b
12 
4  
  9
12 
4  
   
3 6
12 
 5 
78 
12 
4  
 8 
1  
   
  9
   
45 
7 9
1  
4  
7  
c
1  
4 6
   
7 5
  3
4  
   
9
1 3
4  
   
2 8
1 3
4 6
   
d
123
4 6
  9
5
 2 
4  
  9
 23
   
 89
 23
  6
 8 
7
1  
  6
 89
 2 
4  
  9
12 
4 6
   
e
1 3
  6
   
1 3
  6
 8 
 2 
   
  9
  3
   
 8 
4 5 7
 2 
   
  9
1  
  6
   
f
 2 
4 6
  9
 2 
4 6
 8 
7 1
 2 
  6
 8 
 2 
  6
 89
   
  6
 89
3 5
g
 23
4  
7  
 23
4  
   
1
 23
4  
7 9
 23
   
7  
 23
4  
  9
5 6 8
h
 2 
4  
7  
 2 
4  
   
8 5
 2 
  6
7  
 2 
4 6
   
3 1 9
i 5 9 6
  3
   
 8 
1 3
   
 8 
1 3
   
 8 
4
 2 
   
7  
 2 
   
7  

backtrack.grid39 → grid40: b7 guess 1 ∈ {1|9}

pending={b7}

deduce.grid40: naked-singles

deduce.grid40: hidden-singles

deduce.grid40: naked-pairs

two's heap=b2 {2|4}, h2 {2|4}, i9 {2|7}, c4 {3|4}, i8 {2|7}, b9 {4|7}, e8 {2|9}, a7 {6|9}, e9 {1|6}, e3 {2|9}, i4 {3|8}, e4 {3|8}.

Naked-pair {2|4} in cells {b2, h2} contained within {col2}, updating cells {a2, e2, f2, g2}:

Naked-pair {2|7} in cells {i8, i9} contained within {rowi, box9}, updating cells {i4, i5, i6}:

Naked-pair {3|8} in cells {e4, i4} contained within {col4}, updating cells {a4, c4, d4, g4}:

Naked-pair {2|9} in cells {e3, e8} contained within {rowe}, updating cells {e1, e2, e4, e9}:

pending={c4, g2}

deduce.grid40: naked-singles

deduce.grid40: hidden-singles

deduce.grid40.rowf. f1 is 4 by hidden-single.

pending={f1}

deduce.grid40: naked-singles

deduce.grid40: hidden-singles

deduce.grid40.rowg. g6 is 4 by hidden-single.

pending={g6}

deduce.grid40: naked-singles

deduce.grid40: hidden-singles

deduce.grid40.rowg. g4 is 9 by hidden-single.

pending={g4}

deduce.grid40: naked-singles

deduce.grid40: hidden-singles

deduce.grid40.rowa. a7 is 9 by hidden-single.

pending={a7}

deduce.grid40: naked-singles

deduce.grid40: hidden-singles

grid40 didn't work: rowf is not bijective.

…backtrack.grid39 again

backtrack.grid39 → grid41: b7 guess 9 ∈ {1|9}

pending={b7}

deduce.grid41: naked-singles

deduce.grid41: hidden-singles

deduce.grid41.rowa. a3 is 9 by hidden-single.

pending={a3}

deduce.grid41: naked-singles

deduce.grid41: hidden-singles

grid41 didn't work: rowf is not bijective.

…backtrack.grid39 again

grid39 didn't work: exhaustive search revealed no solution.

…backtrack.grid35 again

grid35 didn't work: exhaustive search revealed no solution.

…backtrack.grid31 again

grid31 didn't work: exhaustive search revealed no solution.

…backtrack.grid3 again

grid3 didn't work: exhaustive search revealed no solution.

…backtrack.grid2 again

backtrack.grid2 → grid42: g7 guess 9 ∈ {5|9}

pending={g7}

deduce.grid42: naked-singles

deduce.grid42: hidden-singles

deduce.grid42.rowg. g1 is 5 by hidden-single.

pending={g1}

deduce.grid42: naked-singles

deduce.grid42: hidden-singles

deduce.grid42.rowh. h6 is 9 by hidden-single.

pending={h6}

deduce.grid42: naked-singles

deduce.grid42: hidden-singles

deduce.grid42: naked-pairs

two's heap=h9 {2|7}.

grid42
1 2 3 4 5 6 7 8 9
a 8
12 
4 6
   
 2 
456
  9
 23
4  
7  
123
 5 
7  
123
4  
   
1  
 56
   
   
45 
7 9
1 3
456
7 9
b
12 
4  
  9
12 
4  
   
3 6
12 
 5 
78 
12 
4  
 8 
1  
 5 
 8 
   
45 
789
1  
45 
7 9
c
1  
4 6
   
7
   
456
   
  3
4  
 8 
9
1 3
4  
 8 
2
   
45 
 8 
1 3
456
   
d
123
4 6
  9
5
 2 
4 6
  9
 23
   
 89
 23
  6
 8 
7
1  
  6
 8 
 2 
4  
 89
12 
4 6
  9
e
123
  6
  9
123
  6
 8 
 2 
  6
  9
 23
   
 89
4 5 7
 2 
   
 89
12 
  6
  9
f
 2 
4 6
7 9
 2 
4 6
 8 
 2 
4 6
7 9
1
 2 
  6
 8 
 2 
  6
 8 
   
 56
 8 
3
 2 
456
  9
g 5
 23
4  
   
1
 23
4  
7  
 23
   
7  
 23
4  
   
9 6 8
h
 2 
4 6
7  
 2 
4 6
   
8 5
 2 
  6
7  
9 3 1
 2 
   
7  
i
 23
  6
7  
9
 2 
  6
7  
 23
   
78 
123
  6
78 
123
  6
 8 
4
 2 
 5 
7  
 2 
 5 
7  

backtrack.grid42 → grid43: h9 guess 2 ∈ {2|7}

pending={h9}

deduce.grid43: naked-singles

deduce.grid43: hidden-singles

deduce.grid43: naked-pairs

two's heap=h2 {4|6}, i9 {5|7}, i8 {5|7}, h5 {6|7}.

Naked-pair {5|7} in cells {i8, i9} contained within {rowi, box9}, updating cells {i1, i3, i4, i5, i6}:

grid43
1 2 3 4 5 6 7 8 9
a 8
12 
4 6
   
 2 
456
  9
 23
4  
7  
123
 5 
7  
123
4  
   
1  
 56
   
   
45 
7 9
1 3
456
7 9
b
12 
4  
  9
12 
4  
   
3 6
12 
 5 
78 
12 
4  
 8 
1  
 5 
 8 
   
45 
789
1  
45 
7 9
c
1  
4 6
   
7
   
456
   
  3
4  
 8 
9
1 3
4  
 8 
2
   
45 
 8 
1 3
456
   
d
123
4 6
  9
5
 2 
4 6
  9
 23
   
 89
 23
  6
 8 
7
1  
  6
 8 
 2 
4  
 89
1  
4 6
  9
e
123
  6
  9
123
  6
 8 
 2 
  6
  9
 23
   
 89
4 5 7
 2 
   
 89
1  
  6
  9
f
 2 
4 6
7 9
 2 
4 6
 8 
 2 
4 6
7 9
1
 2 
  6
 8 
 2 
  6
 8 
   
 56
 8 
3
   
456
  9
g 5
 23
4  
   
1
 23
4  
7  
 23
   
7  
 23
4  
   
9 6 8
h
   
4 6
7  
   
4 6
   
8 5
   
  6
7  
9 3 1 2
i
 23
  6
   
9
 2 
  6
   
 23
   
 8 
123
  6
 8 
123
  6
 8 
4
   
 5 
7  
   
 5 
7  

backtrack.grid43 → grid44: h2 guess 4 ∈ {4|6}

pending={h2}

deduce.grid44: naked-singles

deduce.grid44: hidden-singles

deduce.grid44.col3. f3 is 7 by hidden-single.

pending={f3}

deduce.grid44: naked-singles

deduce.grid44: hidden-singles

deduce.grid44.col1. h1 is 7 by hidden-single.

pending={h1}

deduce.grid44: naked-singles

deduce.grid44: hidden-singles

deduce.grid44.col6. f6 is 6 by hidden-single.

pending={f6}

deduce.grid44: naked-singles

deduce.grid44: hidden-singles

deduce.grid44: naked-pairs

two's heap=b2 {1|2}, g2 {2|3}, i3 {2|6}, i9 {5|7}, f2 {2|8}, f5 {2|8}, i8 {5|7}, f7 {5|8}.

Naked-pair {5|7} in cells {i8, i9} contained within {rowi, box9}, updating cells {i1, i3, i4, i5, i6}:

Naked-pair {2|8} in cells {f2, f5} contained within {rowf}, updating cells {f1, f7, f9}:

pending={f7}

deduce.grid44: naked-singles

deduce.grid44: hidden-singles

deduce.grid44: naked-pairs

two's heap=b2 {1|2}, g2 {2|3}, b7 {1|8}, a7 {1|6}, i8 {5|7}, f5 {2|8}, f9 {4|9}, f1 {4|9}, i3 {2|6}, f2 {2|8}, i9 {5|7}.

Naked-pair {5|7} in cells {i8, i9} contained within {rowi, box9}, updating cells {i1, i3, i4, i5, i6}:

Naked-pair {2|8} in cells {f2, f5} contained within {rowf}, updating cells {f1, f9}:

Naked-pair {4|9} in cells {f1, f9} contained within {rowf}, updating cells {f2, f5}:

grid44
1 2 3 4 5 6 7 8 9
a 8
12 
  6
   
 2 
456
  9
 23
4  
7  
123
 5 
7  
123
4  
   
1  
  6
   
   
45 
7 9
1 3
456
7 9
b
12 
4  
  9
12 
   
   
3 6
12 
 5 
78 
12 
4  
 8 
1  
   
 8 
   
45 
789
1  
45 
7 9
c
1  
4 6
   
7
   
456
   
  3
4  
 8 
9
1 3
4  
 8 
2
   
45 
 8 
1 3
456
   
d
123
4 6
  9
5
 2 
4 6
  9
 23
   
 89
 23
   
 8 
7
1  
  6
 8 
 2 
4  
 89
1  
4 6
  9
e
123
  6
  9
123
  6
 8 
 2 
  6
  9
 23
   
 89
4 5 7
 2 
   
 89
1  
  6
  9
f
   
4  
  9
 2 
   
 8 
7 1
 2 
   
 8 
6 5 3
   
4  
  9
g 5
 23
   
   
1
 23
4  
7  
 23
   
7  
 23
4  
   
9 6 8
h 7 4 8 5 6 9 3 1 2
i
 23
  6
   
9
 2 
  6
   
 23
   
 8 
123
   
 8 
123
   
 8 
4
   
 5 
7  
   
 5 
7  

backtrack.grid44 → grid45: a7 guess 1 ∈ {1|6}

pending={a7}

deduce.grid45: naked-singles

deduce.grid45: hidden-singles

deduce.grid45: naked-pairs

two's heap=b2 {1|2}, g2 {2|3}, c8 {4|5}, a2 {2|6}, i3 {2|6}, i9 {5|7}, f5 {2|8}, f9 {4|9}, e9 {1|9}, f1 {4|9}, i8 {5|7}, f2 {2|8}.

Naked-pair {5|7} in cells {i8, i9} contained within {rowi, box9}, updating cells {i1, i3, i4, i5, i6}:

Naked-pair {2|8} in cells {f2, f5} contained within {rowf}, updating cells {f1, f9}:

Naked-pair {4|9} in cells {f1, f9} contained within {rowf}, updating cells {f2, f5}:

grid45
1 2 3 4 5 6 7 8 9
a 8
 2 
  6
   
 2 
456
  9
 23
4  
7  
 23
 5 
7  
 23
4  
   
1
   
45 
7 9
  3
456
7 9
b
12 
4  
  9
12 
   
   
3 6
12 
 5 
7  
12 
4  
   
8
   
45 
7 9
   
45 
7 9
c
1  
4 6
   
7
   
456
   
  3
4  
 8 
9
1 3
4  
 8 
2
   
45 
   
  3
456
   
d
123
4  
  9
5
 2 
4  
  9
 23
   
 89
 23
   
 8 
7 6
 2 
4  
 89
1  
4  
  9
e
123
  6
  9
123
  6
 8 
 2 
  6
  9
 23
   
 89
4 5 7
 2 
   
 89
1  
   
  9
f
   
4  
  9
 2 
   
 8 
7 1
 2 
   
 8 
6 5 3
   
4  
  9
g 5
 23
   
   
1
 23
4  
7  
 23
   
7  
 23
4  
   
9 6 8
h 7 4 8 5 6 9 3 1 2
i
 23
  6
   
9
 2 
  6
   
 23
   
 8 
123
   
 8 
123
   
 8 
4
   
 5 
7  
   
 5 
7  

backtrack.grid45 → grid46: a2 guess 2 ∈ {2|6}

pending={a2}

deduce.grid46: naked-singles

grid46 didn't work: naked-singles ran out of candidates.

…backtrack.grid45 again

backtrack.grid45 → grid47: a2 guess 6 ∈ {2|6}

pending={a2}

deduce.grid47: naked-singles

deduce.grid47: hidden-singles

deduce.grid47.rowc. c9 is 6 by hidden-single.

pending={c9}

deduce.grid47: naked-singles

deduce.grid47: hidden-singles

deduce.grid47.col9. a9 is 3 by hidden-single.

pending={a9}

deduce.grid47: naked-singles

deduce.grid47: hidden-singles

deduce.grid47: naked-pairs

two's heap=b2 {1|2}, g2 {2|3}, c1 {1|4}, c3 {4|5}, a6 {2|4}, i3 {2|6}, i9 {5|7}, f2 {2|8}, f5 {2|8}, f9 {4|9}, c8 {4|5}, e9 {1|9}, i8 {5|7}, f1 {4|9}.

Naked-pair {4|5} in cells {c3, c8} contained within {rowc}, updating cells {c1, c4, c6}:

Naked-pair {5|7} in cells {i8, i9} contained within {rowi, box9}, updating cells {i1, i3, i4, i5, i6}:

Naked-pair {2|8} in cells {f2, f5} contained within {rowf}, updating cells {f1, f9}:

Naked-pair {4|9} in cells {f1, f9} contained within {rowf}, updating cells {f2, f5}:

pending={c1}

deduce.grid47: naked-singles

grid47 didn't work: naked-singles ran out of candidates.

…backtrack.grid45 again

grid45 didn't work: exhaustive search revealed no solution.

…backtrack.grid44 again

backtrack.grid44 → grid48: a7 guess 6 ∈ {1|6}

pending={a7}

deduce.grid48: naked-singles

deduce.grid48: hidden-singles

deduce.grid48.col2. e2 is 6 by hidden-single.

pending={e2}

deduce.grid48: naked-singles

deduce.grid48: hidden-singles

deduce.grid48.rowd. d9 is 6 by hidden-single.

pending={d9}

deduce.grid48: naked-singles

deduce.grid48: hidden-singles

deduce.grid48.col2. f2 is 8 by hidden-single.

deduce.grid48.col2. g2 is 3 by hidden-single.

pending={f2, g2}

deduce.grid48: naked-singles

deduce.grid48: hidden-singles

deduce.grid48.col4. a4 is 7 by hidden-single.

pending={a4}

deduce.grid48: naked-singles

deduce.grid48: hidden-singles

deduce.grid48: naked-pairs

two's heap=a2 {1|2}, b2 {1|2}, i1 {2|6}, d5 {3|8}, g4 {2|4}, i3 {2|6}, i8 {5|7}, f1 {4|9}, f9 {4|9}, d7 {1|8}, g6 {2|4}, e3 {2|9}, b7 {1|8}, e9 {1|9}, i9 {5|7}.

Naked-pair {1|2} in cells {a2, b2} contained within {col2, box1}, updating cells {a3, b1, c1, c3}:

Naked-pair {2|4} in cells {g4, g6} contained within {rowg, box8}, updating cells {i4, i5, i6}:

Naked-pair {2|6} in cells {i1, i3} contained within {rowi, box7}, updating cells {i4, i5, i6, i8, i9}:

Naked-pair {5|7} in cells {i8, i9} contained within {rowi, box9}, updating cells {i1, i3, i4, i5, i6}:

grid48
1 2 3 4 5 6 7 8 9
a 8
12 
   
   
   
45 
  9
7
1 3
 5 
   
123
4  
   
6
   
45 
  9
1 3
45 
  9
b
   
4  
  9
12 
   
   
3 6
1  
 5 
 8 
12 
4  
 8 
1  
   
 8 
   
45 
789
1  
45 
7 9
c
   
4 6
   
7
   
456
   
  3
4  
 8 
9
1 3
4  
 8 
2
   
45 
 8 
1 3
45 
   
d
123
4  
  9
5
 2 
4  
  9
  3
   
 89
  3
   
 8 
7
1  
   
 8 
 2 
4  
 89
6
e
123
   
  9
6
 2 
   
  9
  3
   
 89
4 5 7
 2 
   
 89
1  
   
  9
f
   
4  
  9
8 7 1 2 6 5 3
   
4  
  9
g 5 3 1
 2 
4  
   
7
 2 
4  
   
9 6 8
h 7 4 8 5 6 9 3 1 2
i
 2 
  6
   
9
 2 
  6
   
  3
   
 8 
1 3
   
 8 
1 3
   
 8 
4
   
 5 
7  
   
 5 
7  

backtrack.grid48 → grid49: a2 guess 1 ∈ {1|2}

pending={a2}

deduce.grid49: naked-singles

deduce.grid49: hidden-singles

deduce.grid49.rowa. a6 is 2 by hidden-single.

pending={a6}

deduce.grid49: naked-singles

deduce.grid49: hidden-singles

deduce.grid49.col4. c4 is 4 by hidden-single.

pending={c4}

deduce.grid49: naked-singles

grid49 didn't work: naked-singles ran out of candidates.

…backtrack.grid48 again

backtrack.grid48 → grid50: a2 guess 2 ∈ {1|2}

pending={a2}

deduce.grid50: naked-singles

grid50 didn't work: naked-singles ran out of candidates.

…backtrack.grid48 again

grid48 didn't work: exhaustive search revealed no solution.

…backtrack.grid44 again

grid44 didn't work: exhaustive search revealed no solution.

…backtrack.grid43 again

backtrack.grid43 → grid51: h2 guess 6 ∈ {4|6}

pending={h2}

deduce.grid51: naked-singles

grid51 didn't work: naked-singles ran out of candidates.

…backtrack.grid43 again

grid43 didn't work: exhaustive search revealed no solution.

…backtrack.grid42 again

backtrack.grid42 → grid52: h9 guess 7 ∈ {2|7}

pending={h9}

deduce.grid52: naked-singles

deduce.grid52: hidden-singles

deduce.grid52: naked-pairs

two's heap=i8 {2|5}, h5 {2|6}, i9 {2|5}.

Naked-pair {2|5} in cells {i8, i9} contained within {rowi, box9}, updating cells {i1, i3, i4, i5, i6}:

grid52
1 2 3 4 5 6 7 8 9
a 8
12 
4 6
   
 2 
456
  9
 23
4  
7  
123
 5 
7  
123
4  
   
1  
 56
   
   
45 
7 9
1 3
456
  9
b
12 
4  
  9
12 
4  
   
3 6
12 
 5 
78 
12 
4  
 8 
1  
 5 
 8 
   
45 
789
1  
45 
  9
c
1  
4 6
   
7
   
456
   
  3
4  
 8 
9
1 3
4  
 8 
2
   
45 
 8 
1 3
456
   
d
123
4 6
  9
5
 2 
4 6
  9
 23
   
 89
 23
  6
 8 
7
1  
  6
 8 
 2 
4  
 89
12 
4 6
  9
e
123
  6
  9
123
  6
 8 
 2 
  6
  9
 23
   
 89
4 5 7
 2 
   
 89
12 
  6
  9
f
 2 
4 6
7 9
 2 
4 6
 8 
 2 
4 6
7 9
1
 2 
  6
 8 
 2 
  6
 8 
   
 56
 8 
3
 2 
456
  9
g 5
 23
4  
   
1
 23
4  
7  
 23
   
7  
 23
4  
   
9 6 8
h
 2 
4 6
   
 2 
4 6
   
8 5
 2 
  6
   
9 3 1 7
i
  3
  6
7  
9
   
  6
7  
  3
   
78 
1 3
  6
78 
1 3
  6
 8 
4
 2 
 5 
   
 2 
 5 
   

backtrack.grid52 → grid53: h5 guess 2 ∈ {2|6}

pending={h5}

deduce.grid53: naked-singles

deduce.grid53: hidden-singles

deduce.grid53.rowg. g2 is 2 by hidden-single.

pending={g2}

deduce.grid53: naked-singles

deduce.grid53: hidden-singles

deduce.grid53.col2. e2 is 3 by hidden-single.

pending={e2}

deduce.grid53: naked-singles

deduce.grid53: hidden-singles

deduce.grid53.col1. i1 is 3 by hidden-single.

pending={i1}

deduce.grid53: naked-singles

deduce.grid53: hidden-singles

deduce.grid53.col1. f1 is 7 by hidden-single.

pending={f1}

deduce.grid53: naked-singles

deduce.grid53: hidden-singles

deduce.grid53.col2. f2 is 8 by hidden-single.

pending={f2}

deduce.grid53: naked-singles

deduce.grid53: hidden-singles

deduce.grid53.rowb. b1 is 2 by hidden-single.

pending={b1}

deduce.grid53: naked-singles

deduce.grid53: hidden-singles

deduce.grid53.rowa. a4 is 2 by hidden-single.

pending={a4}

deduce.grid53: naked-singles

deduce.grid53: hidden-singles

deduce.grid53.col3. i3 is 7 by hidden-single.

pending={i3}

deduce.grid53: naked-singles

deduce.grid53: hidden-singles

deduce.grid53.rowe. e8 is 8 by hidden-single.

pending={e8}

deduce.grid53: naked-singles

grid53 didn't work: naked-singles ran out of candidates.

…backtrack.grid52 again

backtrack.grid52 → grid54: h5 guess 6 ∈ {2|6}

pending={h5}

deduce.grid54: naked-singles

deduce.grid54: hidden-singles

deduce.grid54.col6. f6 is 6 by hidden-single.

pending={f6}

deduce.grid54: naked-singles

deduce.grid54: hidden-singles

deduce.grid54: naked-pairs

two's heap=h1 {2|4}, h2 {2|4}, i8 {2|5}, f7 {5|8}, i3 {6|7}, f5 {2|8}, i9 {2|5}.

Naked-pair {2|4} in cells {h1, h2} contained within {rowh, box7}, updating cells {g2, i1, i3}:

Naked-pair {2|5} in cells {i8, i9} contained within {rowi, box9}, updating cells {i1, i3, i4, i5, i6}:

pending={g2}

deduce.grid54: naked-singles

deduce.grid54: hidden-singles

deduce.grid54: naked-pairs

two's heap=g6 {2|4}, h1 {2|4}, h2 {2|4}, i8 {2|5}, i9 {2|5}, f5 {2|8}, i1 {6|7}, f7 {5|8}, i3 {6|7}, g5 {2|7}.

Naked-pair {2|4} in cells {g6, h1, h2} contained within {rowh, box7}, updating cells {i1, i3}:

Naked-pair {2|5} in cells {i8, i9} contained within {rowi, box9}, updating cells {i1, i3, i4, i5, i6}:

Naked-pair {6|7} in cells {i1, i3} contained within {rowi, box7}, updating cells {h1, h2, i4, i5, i6, i8, i9}:

grid54
1 2 3 4 5 6 7 8 9
a 8
12 
4 6
   
 2 
456
  9
 23
4  
7  
123
 5 
7  
123
4  
   
1  
 56
   
   
45 
7 9
1 3
456
  9
b
12 
4  
  9
12 
4  
   
3 6
12 
 5 
78 
12 
4  
 8 
1  
 5 
 8 
   
45 
789
1  
45 
  9
c
1  
4 6
   
7
   
456
   
  3
4  
 8 
9
1 3
4  
 8 
2
   
45 
 8 
1 3
456
   
d
123
4 6
  9
5
 2 
4 6
  9
 23
   
 89
 23
   
 8 
7
1  
  6
 8 
 2 
4  
 89
12 
4 6
  9
e
123
  6
  9
12 
  6
 8 
 2 
  6
  9
 23
   
 89
4 5 7
 2 
   
 89
12 
  6
  9
f
 2 
4  
7 9
 2 
4  
 8 
 2 
4  
7 9
1
 2 
   
 8 
6
   
 5 
 8 
3
 2 
45 
  9
g 5 3 1
 2 
4  
7  
 2 
   
7  
 2 
4  
   
9 6 8
h
 2 
4  
   
 2 
4  
   
8 5 6 9 3 1 7
i
   
  6
7  
9
   
  6
7  
  3
   
 8 
1 3
   
 8 
1 3
   
 8 
4
 2 
 5 
   
 2 
 5 
   

backtrack.grid54 → grid55: f5 guess 2 ∈ {2|8}

pending={f5}

deduce.grid55: naked-singles

deduce.grid55: hidden-singles

deduce.grid55.rowb. b8 is 7 by hidden-single.

pending={b8}

deduce.grid55: naked-singles

deduce.grid55: hidden-singles

deduce.grid55.rowa. a4 is 7 by hidden-single.

pending={a4}

deduce.grid55: naked-singles

deduce.grid55: hidden-singles

deduce.grid55.col4. g4 is 2 by hidden-single.

pending={g4}

deduce.grid55: naked-singles

deduce.grid55: hidden-singles

deduce.grid55.col4. c4 is 4 by hidden-single.

pending={c4}

deduce.grid55: naked-singles

deduce.grid55: hidden-singles

deduce.grid55: naked-pairs

two's heap=h1 {2|4}, h2 {2|4}, i8 {2|5}, c3 {5|6}, i3 {6|7}, i9 {2|5}, c8 {5|8}, d5 {3|8}, i1 {6|7}, f2 {4|8}, i4 {3|8}, f7 {5|8}, c1 {1|6}.

Naked-pair {2|4} in cells {h1, h2} contained within {rowh, box7}, updating cells {i1, i3}:

Naked-pair {2|5} in cells {i8, i9} contained within {rowi, box9}, updating cells {i1, i3, i4, i5, i6}:

Naked-pair {6|7} in cells {i1, i3} contained within {rowi, box7}, updating cells {h1, h2, i4, i5, i6, i8, i9}:

grid55
1 2 3 4 5 6 7 8 9
a 8
12 
4 6
   
 2 
456
  9
7
1 3
 5 
   
123
   
   
1  
 56
   
   
45 
  9
1 3
456
  9
b
12 
4  
  9
12 
4  
   
3 6
1  
 5 
 8 
12 
   
 8 
1  
 5 
 8 
7
1  
45 
  9
c
1  
  6
   
7
   
 56
   
4 9
1 3
   
 8 
2
   
 5 
 8 
1 3
 56
   
d
123
4 6
  9
5
 2 
4 6
  9
  3
   
 89
  3
   
 8 
7
1  
  6
 8 
 2 
4  
 89
12 
4 6
  9
e
123
  6
  9
12 
  6
 8 
 2 
  6
  9
  3
   
 89
4 5 7
 2 
   
 89
12 
  6
  9
f
   
4  
7 9
   
4  
 8 
   
4  
7 9
1 2 6
   
 5 
 8 
3
   
45 
  9
g 5 3 1 2 7 4 9 6 8
h
 2 
4  
   
 2 
4  
   
8 5 6 9 3 1 7
i
   
  6
7  
9
   
  6
7  
  3
   
 8 
1 3
   
 8 
1 3
   
 8 
4
 2 
 5 
   
 2 
 5 
   

backtrack.grid55 → grid56: c1 guess 1 ∈ {1|6}

pending={c1}

deduce.grid56: naked-singles

deduce.grid56: hidden-singles

deduce.grid56.col2. e2 is 1 by hidden-single.

pending={e2}

deduce.grid56: naked-singles

deduce.grid56: hidden-singles

deduce.grid56.col2. a2 is 6 by hidden-single.

deduce.grid56.col2. f2 is 8 by hidden-single.

pending={a2, f2}

deduce.grid56: naked-singles

grid56 didn't work: naked-singles ran out of candidates.

…backtrack.grid55 again

backtrack.grid55 → grid57: c1 guess 6 ∈ {1|6}

pending={c1}

deduce.grid57: naked-singles

deduce.grid57: hidden-singles

deduce.grid57.rowf. f3 is 7 by hidden-single.

pending={f3}

deduce.grid57: naked-singles

deduce.grid57: hidden-singles

deduce.grid57.col2. e2 is 6 by hidden-single.

pending={e2}

deduce.grid57: naked-singles

deduce.grid57: hidden-singles

deduce.grid57.rowe. e4 is 8 by hidden-single.

pending={e4}

deduce.grid57: naked-singles

deduce.grid57: hidden-singles

deduce.grid57.rowd. d7 is 8 by hidden-single.

pending={d7}

deduce.grid57: naked-singles

grid57 didn't work: naked-singles ran out of candidates.

…backtrack.grid55 again

grid55 didn't work: exhaustive search revealed no solution.

…backtrack.grid54 again

backtrack.grid54 → grid58: f5 guess 8 ∈ {2|8}

pending={f5}

deduce.grid58: naked-singles

deduce.grid58: hidden-singles

deduce.grid58.col2. e2 is 8 by hidden-single.

pending={e2}

deduce.grid58: naked-singles

deduce.grid58: hidden-singles

deduce.grid58.col2. a2 is 6 by hidden-single.

pending={a2}

deduce.grid58: naked-singles

deduce.grid58: hidden-singles

deduce.grid58.rowc. c9 is 6 by hidden-single.

pending={c9}

deduce.grid58: naked-singles

deduce.grid58: hidden-singles

deduce.grid58.rowd. d8 is 8 by hidden-single.

pending={d8}

deduce.grid58: naked-singles

deduce.grid58: hidden-singles

deduce.grid58.col2. b2 is 1 by hidden-single.

pending={b2}

deduce.grid58: naked-singles

grid58 didn't work: naked-singles ran out of candidates.

…backtrack.grid54 again

grid54 didn't work: exhaustive search revealed no solution.

…backtrack.grid52 again

grid52 didn't work: exhaustive search revealed no solution.

…backtrack.grid42 again

grid42 didn't work: exhaustive search revealed no solution.

…backtrack.grid2 again

grid2 didn't work: exhaustive search revealed no solution.

…backtrack.grid1 again

backtrack.grid1 → grid59: h7 guess 9 ∈ {3|9}

pending={h7}

deduce.grid59: naked-singles

deduce.grid59: hidden-singles

deduce.grid59: naked-pairs

two's heap=g7 {3|5}.

grid59
1 2 3 4 5 6 7 8 9
a 8
12 
4 6
   
 2 
456
  9
 23
4  
7  
123
 5 
7  
123
4  
   
1 3
 56
   
   
45 
7 9
1 3
456
7 9
b
12 
45 
  9
12 
4  
   
3 6
12 
 5 
78 
12 
4  
 8 
1  
 5 
 8 
   
45 
789
1  
45 
7 9
c
1  
456
   
7
   
456
   
  3
4  
 8 
9
1 3
4  
 8 
2
   
45 
 8 
1 3
456
   
d
123
4 6
  9
5
 2 
4 6
  9
 23
   
 89
 23
  6
 8 
7
1  
  6
 8 
 2 
4  
 89
12 
4 6
  9
e
123
  6
  9
123
  6
 8 
 2 
  6
  9
 23
   
 89
4 5 7
 2 
   
 89
12 
  6
  9
f
 2 
4 6
7 9
 2 
4 6
 8 
 2 
4 6
7 9
1
 2 
  6
 8 
 2 
  6
 89
   
 56
 8 
3
 2 
456
  9
g
 23
45 
7  
 23
4  
   
1
 23
4  
7 9
 23
   
7  
 23
4  
  9
  3
 5 
   
6 8
h
 23
4 6
7  
 23
4 6
   
8 5
 23
  6
7  
 23
4 6
   
9 1
 23
   
7  
i
 23
 56
7  
9
 2 
 56
7  
 23
   
78 
123
  6
78 
123
  6
 8 
4
 2 
 5 
7  
 23
 5 
7  

backtrack.grid59 → grid60: g7 guess 3 ∈ {3|5}

pending={g7}

deduce.grid60: naked-singles

deduce.grid60: hidden-singles

deduce.grid60.rowg. g1 is 5 by hidden-single.

pending={g1}

deduce.grid60: naked-singles

deduce.grid60: hidden-singles

deduce.grid60: naked-pairs

two's heap=g2 {2|4}, g5 {2|7}, h9 {2|7}.

grid60
1 2 3 4 5 6 7 8 9
a 8
12 
4 6
   
 2 
456
  9
 23
4  
7  
123
 5 
7  
123
4  
   
1  
 56
   
   
45 
7 9
1 3
456
7 9
b
12 
4  
  9
12 
4  
   
3 6
12 
 5 
78 
12 
4  
 8 
1  
 5 
 8 
   
45 
789
1  
45 
7 9
c
1  
4 6
   
7
   
456
   
  3
4  
 8 
9
1 3
4  
 8 
2
   
45 
 8 
1 3
456
   
d
123
4 6
  9
5
 2 
4 6
  9
 23
   
 89
 23
  6
 8 
7
1  
  6
 8 
 2 
4  
 89
12 
4 6
  9
e
123
  6
  9
123
  6
 8 
 2 
  6
  9
 23
   
 89
4 5 7
 2 
   
 89
12 
  6
  9
f
 2 
4 6
7 9
 2 
4 6
 8 
 2 
4 6
7 9
1
 2 
  6
 8 
 2 
  6
 89
   
 56
 8 
3
 2 
456
  9
g 5
 2 
4  
   
1
 2 
4  
7 9
 2 
   
7  
 2 
4  
  9
3 6 8
h
 23
4 6
7  
 23
4 6
   
8 5
 23
  6
7  
 23
4 6
   
9 1
 2 
   
7  
i
 23
  6
7  
9
 2 
  6
7  
 23
   
78 
123
  6
78 
123
  6
 8 
4
 2 
 5 
7  
 2 
 5 
7  

backtrack.grid60 → grid61: g2 guess 2 ∈ {2|4}

pending={g2}

deduce.grid61: naked-singles

deduce.grid61: hidden-singles

deduce.grid61.col4. a4 is 7 by hidden-single.

pending={a4}

deduce.grid61: naked-singles

deduce.grid61: hidden-singles

deduce.grid61: naked-pairs

two's heap=b2 {1|4}, h9 {2|7}, g6 {4|9}, g4 {4|9}, i3 {6|7}.

Naked-pair {4|9} in cells {g4, g6} contained within {rowg, box8}, updating cells {h5, h6, i4, i5, i6}:

grid61
1 2 3 4 5 6 7 8 9
a 8
1  
4 6
   
 2 
456
  9
7
123
 5 
   
123
4  
   
1  
 56
   
   
45 
  9
1 3
456
  9
b
12 
4  
  9
1  
4  
   
3 6
12 
 5 
 8 
12 
4  
 8 
1  
 5 
 8 
   
45 
789
1  
45 
7 9
c
1  
4 6
   
7
   
456
   
  3
4  
 8 
9
1 3
4  
 8 
2
   
45 
 8 
1 3
456
   
d
123
4 6
  9
5
 2 
4 6
  9
 23
   
 89
 23
  6
 8 
7
1  
  6
 8 
 2 
4  
 89
12 
4 6
  9
e
123
  6
  9
1 3
  6
 8 
 2 
  6
  9
 23
   
 89
4 5 7
 2 
   
 89
12 
  6
  9
f
 2 
4 6
7 9
   
4 6
 8 
 2 
4 6
7 9
1
 2 
  6
 8 
 2 
  6
 89
   
 56
 8 
3
 2 
456
  9
g 5 2 1
   
4  
  9
7
   
4  
  9
3 6 8
h
  3
4 6
7  
  3
4 6
   
8 5
 23
  6
   
 23
  6
   
9 1
 2 
   
7  
i
  3
  6
7  
9
   
  6
7  
 23
   
 8 
123
  6
 8 
123
  6
 8 
4
 2 
 5 
7  
 2 
 5 
7  

backtrack.grid61 → grid62: b2 guess 1 ∈ {1|4}

pending={b2}

deduce.grid62: naked-singles

deduce.grid62: hidden-singles

deduce.grid62: naked-pairs

two's heap=a2 {4|6}, b7 {5|8}, c1 {4|6}, g4 {4|9}, g6 {4|9}, h9 {2|7}, i3 {6|7}.

Naked-pair {4|6} in cells {a2, c1} contained within {box1}, updating cells {a3, b1, c3}:

Naked-pair {4|9} in cells {g4, g6} contained within {rowg, box8}, updating cells {h5, h6, i4, i5, i6}:

pending={c3}

deduce.grid62: naked-singles

deduce.grid62: hidden-singles

deduce.grid62: naked-pairs

two's heap=a2 {4|6}, c1 {4|6}, c8 {4|8}, h9 {2|7}, i3 {6|7}, b1 {2|9}, g4 {4|9}, g6 {4|9}, a3 {2|9}, b7 {5|8}.

Naked-pair {4|6} in cells {a2, c1} contained within {box1}, updating cells {a3, b1}:

Naked-pair {2|9} in cells {a3, b1} contained within {box1}, updating cells {a2, c1}:

Naked-pair {4|9} in cells {g4, g6} contained within {rowg, box8}, updating cells {h5, h6, i4, i5, i6}:

grid62
1 2 3 4 5 6 7 8 9
a 8
   
4 6
   
 2 
   
  9
7
123
 5 
   
123
4  
   
1  
 56
   
   
45 
  9
1 3
456
  9
b
 2 
   
  9
1 3 6
 2 
 5 
 8 
 2 
4  
 8 
   
 5 
 8 
   
45 
789
   
45 
7 9
c
   
4 6
   
7 5
  3
4  
 8 
9
1 3
4  
 8 
2
   
4  
 8 
1 3
4 6
   
d
123
4 6
  9
5
 2 
4 6
  9
 23
   
 89
 23
  6
 8 
7
1  
  6
 8 
 2 
4  
 89
12 
4 6
  9
e
123
  6
  9
  3
  6
 8 
 2 
  6
  9
 23
   
 89
4 5 7
 2 
   
 89
12 
  6
  9
f
 2 
4 6
7 9
   
4 6
 8 
 2 
4 6
7 9
1
 2 
  6
 8 
 2 
  6
 89
   
 56
 8 
3
 2 
456
  9
g 5 2 1
   
4  
  9
7
   
4  
  9
3 6 8
h
  3
4 6
7  
  3
4 6
   
8 5
 23
  6
   
 23
  6
   
9 1
 2 
   
7  
i
  3
  6
7  
9
   
  6
7  
 23
   
 8 
123
  6
 8 
123
  6
 8 
4
 2 
 5 
7  
 2 
 5 
7  

backtrack.grid62 → grid63: a2 guess 4 ∈ {4|6}

pending={a2}

deduce.grid63: naked-singles

deduce.grid63: hidden-singles

deduce.grid63.rowh. h1 is 4 by hidden-single.

pending={h1}

deduce.grid63: naked-singles

deduce.grid63: hidden-singles

deduce.grid63.rowh. h9 is 7 by hidden-single.

pending={h9}

deduce.grid63: naked-singles

deduce.grid63: hidden-singles

deduce.grid63.rowb. b8 is 7 by hidden-single.

pending={b8}

deduce.grid63: naked-singles

deduce.grid63: hidden-singles

deduce.grid63: naked-pairs

two's heap=i8 {2|5}, i1 {3|7}, i9 {2|5}, b7 {5|8}, i3 {6|7}, h2 {3|6}, g4 {4|9}, a8 {5|9}, g6 {4|9}, a3 {2|9}, c8 {4|8}, b1 {2|9}, f2 {6|8}.

Naked-pair {2|5} in cells {i8, i9} contained within {rowi, box9}, updating cells {i1, i3, i4, i5, i6}:

Naked-pair {4|9} in cells {g4, g6} contained within {rowg, box8}, updating cells {h5, h6, i4, i5, i6}:

grid63
1 2 3 4 5 6 7 8 9
a 8 4
 2 
   
  9
7
123
 5 
   
123
   
   
1  
 56
   
   
 5 
  9
1 3
 56
  9
b
 2 
   
  9
1 3 6
 2 
 5 
 8 
 2 
4  
 8 
   
 5 
 8 
7
   
45 
  9
c 6 7 5
  3
4  
 8 
9
1 3
4  
 8 
2
   
4  
 8 
1 3
4  
   
d
123
   
  9
5
 2 
4 6
  9
 23
   
 89
 23
  6
 8 
7
1  
  6
 8 
 2 
4  
 89
12 
4 6
  9
e
123
   
  9
  3
  6
 8 
 2 
  6
  9
 23
   
 89
4 5 7
 2 
   
 89
12 
  6
  9
f
 2 
   
7 9
   
  6
 8 
 2 
4 6
7 9
1
 2 
  6
 8 
 2 
  6
 89
   
 56
 8 
3
 2 
456
  9
g 5 2 1
   
4  
  9
7
   
4  
  9
3 6 8
h 4
  3
  6
   
8 5
 23
  6
   
 23
  6
   
9 1 7
i
  3
   
7  
9
   
  6
7  
  3
   
 8 
1 3
  6
 8 
1 3
  6
 8 
4
 2 
 5 
   
 2 
 5 
   

backtrack.grid63 → grid64: a3 guess 2 ∈ {2|9}

pending={a3}

deduce.grid64: naked-singles

deduce.grid64: hidden-singles

deduce.grid64: naked-pairs

two's heap=a6 {1|3}, i9 {2|5}, i8 {2|5}, b9 {4|5}, h2 {3|6}, i1 {3|7}, f1 {2|7}, f2 {6|8}, g4 {4|9}, g6 {4|9}, c8 {4|8}, e3 {6|9}, i3 {6|7}, b7 {5|8}, i4 {3|8}, a8 {5|9}.

Naked-pair {2|5} in cells {i8, i9} contained within {rowi, box9}, updating cells {i1, i3, i4, i5, i6}:

Naked-pair {4|9} in cells {g4, g6} contained within {rowg, box8}, updating cells {h5, h6, i4, i5, i6}:

grid64
1 2 3 4 5 6 7 8 9
a 8 4 2 7
1 3
 5 
   
1 3
   
   
1  
 56
   
   
 5 
  9
1 3
 56
  9
b 9 1 3 6
 2 
 5 
 8 
 2 
4  
 8 
   
 5 
 8 
7
   
45 
   
c 6 7 5
  3
4  
 8 
9
1 3
4  
 8 
2
   
4  
 8 
1 3
4  
   
d
123
   
   
5
   
4 6
  9
 23
   
 89
 23
  6
 8 
7
1  
  6
 8 
 2 
4  
 89
12 
4 6
  9
e
123
   
   
  3
  6
 8 
   
  6
  9
 23
   
 89
4 5 7
 2 
   
 89
12 
  6
  9
f
 2 
   
7  
   
  6
 8 
   
4 6
7 9
1
 2 
  6
 8 
 2 
  6
 89
   
 56
 8 
3
 2 
456
  9
g 5 2 1
   
4  
  9
7
   
4  
  9
3 6 8
h 4
  3
  6
   
8 5
 23
  6
   
 23
  6
   
9 1 7
i
  3
   
7  
9
   
  6
7  
  3
   
 8 
1 3
  6
 8 
1 3
  6
 8 
4
 2 
 5 
   
 2 
 5 
   

backtrack.grid64 → grid65: a6 guess 1 ∈ {1|3}

pending={a6}

deduce.grid65: naked-singles

deduce.grid65: hidden-singles

deduce.grid65.rowc. c9 is 1 by hidden-single.

pending={c9}

deduce.grid65: naked-singles

deduce.grid65: hidden-singles

deduce.grid65.rowe. e1 is 1 by hidden-single.

pending={e1}

deduce.grid65: naked-singles

deduce.grid65: hidden-singles

deduce.grid65.rowd. d7 is 1 by hidden-single.

pending={d7}

deduce.grid65: naked-singles

deduce.grid65: hidden-singles

deduce.grid65.rowi. i5 is 1 by hidden-single.

pending={i5}

deduce.grid65: naked-singles

deduce.grid65: hidden-singles

deduce.grid65.col9. a9 is 3 by hidden-single.

pending={a9}

deduce.grid65: naked-singles

deduce.grid65: hidden-singles

deduce.grid65.col8. i8 is 5 by hidden-single.

pending={i8}

deduce.grid65: naked-singles

deduce.grid65: hidden-singles

deduce.grid65: naked-pairs

two's heap=d1 {2|3}, b9 {4|5}, h2 {3|6}, f1 {2|7}, c8 {4|8}, g4 {4|9}, i1 {3|7}, i3 {6|7}, b7 {5|8}, f2 {6|8}, f7 {5|8}, e3 {6|9}, g6 {4|9}, e8 {2|8}, b5 {2|8}, e9 {6|9}, i4 {3|8}.

Naked-pair {4|9} in cells {g4, g6} contained within {rowg, box8}, updating cells {h5, h6, i4, i6}:

Naked-pair {6|9} in cells {e3, e9} contained within {rowe}, updating cells {e2, e4, e8}:

grid65
1 2 3 4 5 6 7 8 9
a 8 4 2 7 5 1 6 9 3
b 9 1 3 6
 2 
   
 8 
 2 
4  
 8 
   
 5 
 8 
7
   
45 
   
c 6 7 5
  3
4  
 8 
9
  3
4  
 8 
2
   
4  
 8 
1
d
 23
   
   
5
   
4 6
  9
 23
   
 89
 23
  6
 8 
7 1
 2 
4  
 8 
   
4 6
  9
e 1
  3
   
 8 
   
  6
  9
 23
   
 8 
4 5 7
 2 
   
 8 
   
  6
  9
f
 2 
   
7  
   
  6
 8 
   
4 6
7 9
1
 2 
  6
 8 
 2 
  6
 89
   
 5 
 8 
3
   
456
  9
g 5 2 1
   
4  
  9
7
   
4  
  9
3 6 8
h 4
  3
  6
   
8 5
 23
  6
   
 23
  6
   
9 1 7
i
  3
   
7  
9
   
  6
7  
  3
   
 8 
1
  3
  6
 8 
4 5 2

backtrack.grid65 → grid66: b5 guess 2 ∈ {2|8}

pending={b5}

deduce.grid66: naked-singles

deduce.grid66: hidden-singles

deduce.grid66.rowh. h6 is 2 by hidden-single.

pending={h6}

deduce.grid66: naked-singles

deduce.grid66: hidden-singles

deduce.grid66.rowf. f1 is 2 by hidden-single.

pending={f1}

deduce.grid66: naked-singles

grid66 didn't work: naked-singles ran out of candidates.

…backtrack.grid65 again

backtrack.grid65 → grid67: b5 guess 8 ∈ {2|8}

pending={b5}

deduce.grid67: naked-singles

grid67 didn't work: naked-singles ran out of candidates.

…backtrack.grid65 again

grid65 didn't work: exhaustive search revealed no solution.

…backtrack.grid64 again

backtrack.grid64 → grid68: a6 guess 3 ∈ {1|3}

pending={a6}

deduce.grid68: naked-singles

deduce.grid68: hidden-singles

deduce.grid68.rowc. c9 is 3 by hidden-single.

pending={c9}

deduce.grid68: naked-singles

deduce.grid68: hidden-singles

deduce.grid68.rowc. c6 is 1 by hidden-single.

pending={c6}

deduce.grid68: naked-singles

deduce.grid68: hidden-singles

deduce.grid68.rowi. i5 is 1 by hidden-single.

pending={i5}

deduce.grid68: naked-singles

deduce.grid68: hidden-singles

deduce.grid68.col8. i8 is 5 by hidden-single.

pending={i8}

deduce.grid68: naked-singles

deduce.grid68: hidden-singles

deduce.grid68: naked-pairs

two's heap=b9 {4|5}, a7 {1|6}, h6 {2|6}, i1 {3|7}, a9 {1|6}, c4 {4|8}, h2 {3|6}, i3 {6|7}, i4 {3|8}, f1 {2|7}, f2 {6|8}, g4 {4|9}, g6 {4|9}, c8 {4|8}, b5 {2|8}, e3 {6|9}, e8 {2|8}, b7 {5|8}, i6 {6|8}.

Naked-pair {1|6} in cells {a7, a9} contained within {rowa, box3}, updating cells {b7, b9, c8}:

Naked-pair {4|9} in cells {g4, g6} contained within {rowg, box8}, updating cells {h5, h6, i4, i6}:

grid68
1 2 3 4 5 6 7 8 9
a 8 4 2 7 5 3
1  
  6
   
9
1  
  6
   
b 9 1 3 6
 2 
   
 8 
 2 
4  
 8 
   
 5 
 8 
7
   
45 
   
c 6 7 5
   
4  
 8 
9 1 2
   
4  
 8 
3
d
123
   
   
5
   
4 6
  9
 23
   
 89
 23
  6
 8 
7
1  
  6
 8 
 2 
4  
 8 
1  
4 6
  9
e
123
   
   
  3
  6
 8 
   
  6
  9
 23
   
 89
4 5 7
 2 
   
 8 
1  
  6
  9
f
 2 
   
7  
   
  6
 8 
   
4 6
7 9
1
 2 
  6
 8 
 2 
  6
 89
   
 56
 8 
3
   
456
  9
g 5 2 1
   
4  
  9
7
   
4  
  9
3 6 8
h 4
  3
  6
   
8 5
 23
  6
   
 2 
  6
   
9 1 7
i
  3
   
7  
9
   
  6
7  
  3
   
 8 
1
   
  6
 8 
4 5 2

backtrack.grid68 → grid69: a7 guess 1 ∈ {1|6}

pending={a7}

deduce.grid69: naked-singles

deduce.grid69: hidden-singles

deduce.grid69: naked-pairs

two's heap=b9 {4|5}, f1 {2|7}, h6 {2|6}, i1 {3|7}, e8 {2|8}, d7 {6|8}, h2 {3|6}, i3 {6|7}, i4 {3|8}, c8 {4|8}, f2 {6|8}, g4 {4|9}, g6 {4|9}, e3 {6|9}, b5 {2|8}, b7 {5|8}, c4 {4|8}, e9 {1|9}, i6 {6|8}.

Naked-pair {4|9} in cells {g4, g6} contained within {rowg, box8}, updating cells {h5, h6, i4, i6}:

grid69
1 2 3 4 5 6 7 8 9
a 8 4 2 7 5 3 1 9 6
b 9 1 3 6
 2 
   
 8 
 2 
4  
 8 
   
 5 
 8 
7
   
45 
   
c 6 7 5
   
4  
 8 
9 1 2
   
4  
 8 
3
d
123
   
   
5
   
4 6
  9
 23
   
 89
 23
  6
 8 
7
   
  6
 8 
 2 
4  
 8 
1  
4  
  9
e
123
   
   
  3
  6
 8 
   
  6
  9
 23
   
 89
4 5 7
 2 
   
 8 
1  
   
  9
f
 2 
   
7  
   
  6
 8 
   
4 6
7 9
1
 2 
  6
 8 
 2 
  6
 89
   
 56
 8 
3
   
45 
  9
g 5 2 1
   
4  
  9
7
   
4  
  9
3 6 8
h 4
  3
  6
   
8 5
 23
  6
   
 2 
  6
   
9 1 7
i
  3
   
7  
9
   
  6
7  
  3
   
 8 
1
   
  6
 8 
4 5 2

backtrack.grid69 → grid70: b5 guess 2 ∈ {2|8}

pending={b5}

deduce.grid70: naked-singles

deduce.grid70: hidden-singles

deduce.grid70.rowh. h6 is 2 by hidden-single.

pending={h6}

deduce.grid70: naked-singles

deduce.grid70: hidden-singles

deduce.grid70.rowf. f1 is 2 by hidden-single.

pending={f1}

deduce.grid70: naked-singles

deduce.grid70: hidden-singles

deduce.grid70.rowf. f3 is 7 by hidden-single.

pending={f3}

deduce.grid70: naked-singles

grid70 didn't work: naked-singles ran out of candidates.

…backtrack.grid69 again

backtrack.grid69 → grid71: b5 guess 8 ∈ {2|8}

pending={b5}

deduce.grid71: naked-singles

grid71 didn't work: naked-singles ran out of candidates.

…backtrack.grid69 again

grid69 didn't work: exhaustive search revealed no solution.

…backtrack.grid68 again

backtrack.grid68 → grid72: a7 guess 6 ∈ {1|6}

pending={a7}

deduce.grid72: naked-singles

deduce.grid72: hidden-singles

deduce.grid72.rowe. e1 is 1 by hidden-single.

pending={e1}

deduce.grid72: naked-singles

deduce.grid72: hidden-singles

deduce.grid72.rowd. d7 is 1 by hidden-single.

pending={d7}

deduce.grid72: naked-singles

deduce.grid72: hidden-singles

deduce.grid72: naked-pairs

two's heap=d1 {2|3}, h6 {2|6}, b9 {4|5}, f1 {2|7}, e8 {2|8}, b5 {2|8}, h2 {3|6}, i1 {3|7}, i3 {6|7}, c8 {4|8}, f2 {6|8}, f7 {5|8}, g4 {4|9}, e3 {6|9}, g6 {4|9}, b7 {5|8}, c4 {4|8}, e9 {6|9}, i4 {3|8}, i6 {6|8}.

Naked-pair {4|9} in cells {g4, g6} contained within {rowg, box8}, updating cells {h5, h6, i4, i6}:

Naked-pair {6|9} in cells {e3, e9} contained within {rowe}, updating cells {e2, e4, e8}:

grid72
1 2 3 4 5 6 7 8 9
a 8 4 2 7 5 3 6 9 1
b 9 1 3 6
 2 
   
 8 
 2 
4  
 8 
   
 5 
 8 
7
   
45 
   
c 6 7 5
   
4  
 8 
9 1 2
   
4  
 8 
3
d
 23
   
   
5
   
4 6
  9
 23
   
 89
 23
  6
 8 
7 1
 2 
4  
 8 
   
4 6
  9
e 1
  3
   
 8 
   
  6
  9
 23
   
 8 
4 5 7
 2 
   
 8 
   
  6
  9
f
 2 
   
7  
   
  6
 8 
   
4 6
7 9
1
 2 
  6
 8 
 2 
  6
 89
   
 5 
 8 
3
   
456
  9
g 5 2 1
   
4  
  9
7
   
4  
  9
3 6 8
h 4
  3
  6
   
8 5
 23
  6
   
 2 
  6
   
9 1 7
i
  3
   
7  
9
   
  6
7  
  3
   
 8 
1
   
  6
 8 
4 5 2

backtrack.grid72 → grid73: b5 guess 2 ∈ {2|8}

pending={b5}

deduce.grid73: naked-singles

deduce.grid73: hidden-singles

deduce.grid73.rowh. h6 is 2 by hidden-single.

pending={h6}

deduce.grid73: naked-singles

deduce.grid73: hidden-singles

deduce.grid73.rowf. f1 is 2 by hidden-single.

pending={f1}

deduce.grid73: naked-singles

grid73 didn't work: naked-singles ran out of candidates.

…backtrack.grid72 again

backtrack.grid72 → grid74: b5 guess 8 ∈ {2|8}

pending={b5}

deduce.grid74: naked-singles

grid74 didn't work: naked-singles ran out of candidates.

…backtrack.grid72 again

grid72 didn't work: exhaustive search revealed no solution.

…backtrack.grid68 again

grid68 didn't work: exhaustive search revealed no solution.

…backtrack.grid64 again

grid64 didn't work: exhaustive search revealed no solution.

…backtrack.grid63 again

backtrack.grid63 → grid75: a3 guess 9 ∈ {2|9}

pending={a3}

deduce.grid75: naked-singles

deduce.grid75: hidden-singles

deduce.grid75.rowf. f1 is 9 by hidden-single.

deduce.grid75.rowf. f7 is 5 by hidden-single.

pending={f1, f7}

deduce.grid75: naked-singles

deduce.grid75: hidden-singles

deduce.grid75.rowf. f3 is 7 by hidden-single.

pending={f3}

deduce.grid75: naked-singles

deduce.grid75: hidden-singles

deduce.grid75.rowf. f9 is 4 by hidden-single.

pending={f9}

deduce.grid75: naked-singles

deduce.grid75: hidden-singles

deduce.grid75.col4. d4 is 2 by hidden-single.

pending={d4}

deduce.grid75: naked-singles

deduce.grid75: hidden-singles

deduce.grid75.rowd. d8 is 9 by hidden-single.

pending={d8}

deduce.grid75: naked-singles

grid75 didn't work: naked-singles ran out of candidates.

…backtrack.grid63 again

grid63 didn't work: exhaustive search revealed no solution.

…backtrack.grid62 again

backtrack.grid62 → grid76: a2 guess 6 ∈ {4|6}

pending={a2}

deduce.grid76: naked-singles

deduce.grid76: hidden-singles

deduce.grid76.rowa. a5 is 5 by hidden-single.

deduce.grid76.rowa. a9 is 3 by hidden-single.

pending={a5, a9}

deduce.grid76: naked-singles

deduce.grid76: hidden-singles

deduce.grid76.rowf. f9 is 5 by hidden-single.

pending={f9}

deduce.grid76: naked-singles

deduce.grid76: hidden-singles

deduce.grid76.rowh. h2 is 4 by hidden-single.

pending={h2}

deduce.grid76: naked-singles

grid76 didn't work: naked-singles ran out of candidates.

…backtrack.grid62 again

grid62 didn't work: exhaustive search revealed no solution.

…backtrack.grid61 again

backtrack.grid61 → grid77: b2 guess 4 ∈ {1|4}

pending={b2}

deduce.grid77: naked-singles

deduce.grid77: hidden-singles

deduce.grid77.rowh. h1 is 4 by hidden-single.

pending={h1}

deduce.grid77: naked-singles

deduce.grid77: hidden-singles

deduce.grid77.rowh. h9 is 7 by hidden-single.

pending={h9}

deduce.grid77: naked-singles

deduce.grid77: hidden-singles

deduce.grid77.rowb. b8 is 7 by hidden-single.

pending={b8}

deduce.grid77: naked-singles

deduce.grid77: hidden-singles

deduce.grid77: naked-pairs

two's heap=i8 {2|5}, i9 {2|5}, h2 {3|6}, c1 {1|6}, a2 {1|6}, g6 {4|9}, c3 {5|6}, f2 {6|8}, i3 {6|7}, g4 {4|9}.

Naked-pair {2|5} in cells {i8, i9} contained within {rowi, box9}, updating cells {i1, i3, i4, i5, i6}:

Naked-pair {1|6} in cells {a2, c1} contained within {box1}, updating cells {a3, b1, c3}:

Naked-pair {4|9} in cells {g4, g6} contained within {rowg, box8}, updating cells {h5, h6, i4, i5, i6}:

pending={c3}

deduce.grid77: naked-singles

deduce.grid77: hidden-singles

deduce.grid77: naked-pairs

two's heap=i8 {2|5}, c1 {1|6}, i9 {2|5}, h2 {3|6}, i3 {6|7}, a2 {1|6}, g4 {4|9}, g6 {4|9}, a3 {2|9}, c8 {4|8}, i4 {3|8}, b1 {2|9}, f2 {6|8}.

Naked-pair {2|5} in cells {i8, i9} contained within {rowi, box9}, updating cells {i1, i3, i4, i5, i6}:

Naked-pair {1|6} in cells {a2, c1} contained within {box1}, updating cells {a3, b1}:

Naked-pair {2|9} in cells {a3, b1} contained within {box1}, updating cells {a2, c1}:

Naked-pair {4|9} in cells {g4, g6} contained within {rowg, box8}, updating cells {h5, h6, i4, i5, i6}:

grid77
1 2 3 4 5 6 7 8 9
a 8
1  
  6
   
 2 
   
  9
7
123
 5 
   
123
4  
   
1  
 56
   
   
45 
  9
1 3
456
  9
b
 2 
   
  9
4 3 6
12 
 5 
 8 
12 
   
 8 
1  
 5 
 8 
7
1  
 5 
  9
c
1  
  6
   
7 5
  3
4  
 8 
9
1 3
4  
 8 
2
   
4  
 8 
1 3
4 6
   
d
123
  6
  9
5
 2 
4 6
  9
 23
   
 89
 23
  6
 8 
7
1  
  6
 8 
 2 
4  
 89
12 
4 6
  9
e
123
  6
  9
1 3
  6
 8 
 2 
  6
  9
 23
   
 89
4 5 7
 2 
   
 89
12 
  6
  9
f
 2 
  6
7 9
   
  6
 8 
 2 
4 6
7 9
1
 2 
  6
 8 
 2 
  6
 89
   
 56
 8 
3
 2 
456
  9
g 5 2 1
   
4  
  9
7
   
4  
  9
3 6 8
h 4
  3
  6
   
8 5
 23
  6
   
 23
  6
   
9 1 7
i
  3
  6
7  
9
   
  6
7  
  3
   
 8 
1 3
  6
 8 
1 3
  6
 8 
4
 2 
 5 
   
 2 
 5 
   

backtrack.grid77 → grid78: a2 guess 1 ∈ {1|6}

pending={a2}

deduce.grid78: naked-singles

deduce.grid78: hidden-singles

deduce.grid78: naked-pairs

two's heap=i8 {2|5}, a7 {5|6}, i9 {2|5}, i1 {3|7}, i3 {6|7}, h2 {3|6}, g6 {4|9}, a3 {2|9}, c8 {4|8}, f2 {6|8}, i4 {3|8}, g4 {4|9}, b1 {2|9}.

Naked-pair {2|5} in cells {i8, i9} contained within {rowi, box9}, updating cells {i1, i3, i4, i5, i6}:

Naked-pair {4|9} in cells {g4, g6} contained within {rowg, box8}, updating cells {h5, h6, i4, i5, i6}:

grid78
1 2 3 4 5 6 7 8 9
a 8 1
 2 
   
  9
7
 23
 5 
   
 23
4  
   
   
 56
   
   
45 
  9
  3
456
  9
b
 2 
   
  9
4 3 6
12 
 5 
 8 
12 
   
 8 
1  
 5 
 8 
7
1  
 5 
  9
c 6 7 5
  3
4  
 8 
9
1 3
4  
 8 
2
   
4  
 8 
1 3
4  
   
d
123
   
  9
5
 2 
4 6
  9
 23
   
 89
 23
  6
 8 
7
1  
  6
 8 
 2 
4  
 89
12 
4 6
  9
e
123
   
  9
  3
  6
 8 
 2 
  6
  9
 23
   
 89
4 5 7
 2 
   
 89
12 
  6
  9
f
 2 
   
7 9
   
  6
 8 
 2 
4 6
7 9
1
 2 
  6
 8 
 2 
  6
 89
   
 56
 8 
3
 2 
456
  9
g 5 2 1
   
4  
  9
7
   
4  
  9
3 6 8
h 4
  3
  6
   
8 5
 23
  6
   
 23
  6
   
9 1 7
i
  3
   
7  
9
   
  6
7  
  3
   
 8 
1 3
  6
 8 
1 3
  6
 8 
4
 2 
 5 
   
 2 
 5 
   

backtrack.grid78 → grid79: a3 guess 2 ∈ {2|9}

pending={a3}

deduce.grid79: naked-singles

deduce.grid79: hidden-singles

deduce.grid79: naked-pairs

two's heap=a6 {3|4}, b9 {1|5}, i8 {2|5}, i9 {2|5}, h2 {3|6}, i1 {3|7}, a7 {5|6}, a5 {3|5}, g4 {4|9}, g6 {4|9}, c8 {4|8}, e3 {6|9}, i3 {6|7}, i4 {3|8}, f1 {2|7}, f2 {6|8}.

Naked-pair {2|5} in cells {i8, i9} contained within {rowi, box9}, updating cells {i1, i3, i4, i5, i6}:

Naked-pair {4|9} in cells {g4, g6} contained within {rowg, box8}, updating cells {h5, h6, i4, i5, i6}:

grid79
1 2 3 4 5 6 7 8 9
a 8 1 2 7
  3
 5 
   
  3
4  
   
   
 56
   
   
45 
  9
  3
456
  9
b 9 4 3 6
12 
 5 
 8 
12 
   
 8 
1  
 5 
 8 
7
1  
 5 
   
c 6 7 5
  3
4  
 8 
9
1 3
4  
 8 
2
   
4  
 8 
1 3
4  
   
d
123
   
   
5
   
4 6
  9
 23
   
 89
 23
  6
 8 
7
1  
  6
 8 
 2 
4  
 89
12 
4 6
  9
e
123
   
   
  3
  6
 8 
   
  6
  9
 23
   
 89
4 5 7
 2 
   
 89
12 
  6
  9
f
 2 
   
7  
   
  6
 8 
   
4 6
7 9
1
 2 
  6
 8 
 2 
  6
 89
   
 56
 8 
3
 2 
456
  9
g 5 2 1
   
4  
  9
7
   
4  
  9
3 6 8
h 4
  3
  6
   
8 5
 23
  6
   
 23
  6
   
9 1 7
i
  3
   
7  
9
   
  6
7  
  3
   
 8 
1 3
  6
 8 
1 3
  6
 8 
4
 2 
 5 
   
 2 
 5 
   

backtrack.grid79 → grid80: a5 guess 3 ∈ {3|5}

pending={a5}

deduce.grid80: naked-singles

grid80 didn't work: naked-singles ran out of candidates.

…backtrack.grid79 again

backtrack.grid79 → grid81: a5 guess 5 ∈ {3|5}

pending={a5}

deduce.grid81: naked-singles

deduce.grid81: hidden-singles

deduce.grid81.col8. i8 is 5 by hidden-single.

pending={i8}

deduce.grid81: naked-singles

deduce.grid81: hidden-singles

deduce.grid81: naked-pairs

two's heap=a6 {3|4}, d7 {1|8}, b9 {1|5}, f7 {5|8}, c8 {4|8}, h2 {3|6}, f1 {2|7}, a8 {4|9}, f2 {6|8}, g4 {4|9}, g6 {4|9}, e3 {6|9}, i1 {3|7}, i3 {6|7}, i4 {3|8}.

Naked-pair {4|9} in cells {a8, g4, g6} contained within {rowg, box8}, updating cells {h5, h6, i4, i5, i6}:

grid81
1 2 3 4 5 6 7 8 9
a 8 1 2 7 5
  3
4  
   
6
   
4  
  9
  3
4  
  9
b 9 4 3 6
12 
   
 8 
12 
   
 8 
1  
 5 
 8 
7
1  
 5 
   
c 6 7 5
  3
4  
 8 
9
1 3
4  
 8 
2
   
4  
 8 
1 3
4  
   
d
123
   
   
5
   
4 6
  9
 23
   
 89
 23
  6
 8 
7
1  
   
 8 
 2 
4  
 89
1  
4 6
  9
e
123
   
   
  3
  6
 8 
   
  6
  9
 23
   
 89
4 5 7
 2 
   
 89
1  
  6
  9
f
 2 
   
7  
   
  6
 8 
   
4 6
7 9
1
 2 
  6
 8 
 2 
  6
 89
   
 5 
 8 
3
   
456
  9
g 5 2 1
   
4  
  9
7
   
4  
  9
3 6 8
h 4
  3
  6
   
8 5
 23
  6
   
 23
  6
   
9 1 7
i
  3
   
7  
9
   
  6
7  
  3
   
 8 
1 3
  6
 8 
1 3
  6
 8 
4 5 2

backtrack.grid81 → grid82: a6 guess 3 ∈ {3|4}

pending={a6}

deduce.grid82: naked-singles

deduce.grid82: hidden-singles

deduce.grid82.rowc. c9 is 3 by hidden-single.

pending={c9}

deduce.grid82: naked-singles

deduce.grid82: hidden-singles

deduce.grid82.rowc. c6 is 1 by hidden-single.

pending={c6}

deduce.grid82: naked-singles

deduce.grid82: hidden-singles

deduce.grid82.rowi. i5 is 1 by hidden-single.

pending={i5}

deduce.grid82: naked-singles

deduce.grid82: hidden-singles

deduce.grid82.col6. g6 is 4 by hidden-single.

pending={g6}

deduce.grid82: naked-singles

deduce.grid82: hidden-singles

deduce.grid82.col4. c4 is 4 by hidden-single.

pending={c4}

deduce.grid82: naked-singles

deduce.grid82: hidden-singles

deduce.grid82.col6. f6 is 9 by hidden-single.

pending={f6}

deduce.grid82: naked-singles

deduce.grid82: hidden-singles

deduce.grid82: naked-pairs

two's heap=b7 {1|5}, f1 {2|7}, b9 {1|5}, i3 {6|7}, b5 {2|8}, h2 {3|6}, h6 {2|6}, i4 {3|8}, i6 {6|8}, b6 {2|8}, f2 {6|8}, a8 {4|9}, f7 {5|8}, d7 {1|8}, i1 {3|7}, e3 {6|9}, e8 {2|9}, a9 {4|9}.

Naked-pair {1|5} in cells {b7, b9} contained within {rowb, box3}, updating cells {a8, a9, b5, b6}:

Naked-pair {2|8} in cells {b5, b6} contained within {rowb, box2}, updating cells {b7, b9}:

Naked-pair {4|9} in cells {a8, a9} contained within {rowa, box3}, updating cells {b7, b9}:

grid82
1 2 3 4 5 6 7 8 9
a 8 1 2 7 5 3 6
   
4  
  9
   
4  
  9
b 9 4 3 6
 2 
   
 8 
 2 
   
 8 
1  
 5 
   
7
1  
 5 
   
c 6 7 5 4 9 1 2 8 3
d
123
   
   
5
   
4 6
  9
 23
   
 8 
 23
  6
 8 
7
1  
   
 8 
 2 
4  
  9
1  
4 6
  9
e
123
   
   
  3
  6
 8 
   
  6
  9
 23
   
 8 
4 5 7
 2 
   
  9
1  
  6
  9
f
 2 
   
7  
   
  6
 8 
   
4 6
7  
1
 2 
  6
 8 
9
   
 5 
 8 
3
   
456
   
g 5 2 1 9 7 4 3 6 8
h 4
  3
  6
   
8 5
 23
  6
   
 2 
  6
   
9 1 7
i
  3
   
7  
9
   
  6
7  
  3
   
 8 
1
   
  6
 8 
4 5 2

backtrack.grid82 → grid83: a8 guess 4 ∈ {4|9}

pending={a8}

deduce.grid83: naked-singles

deduce.grid83: hidden-singles

deduce.grid83: naked-pairs

two's heap=b7 {1|5}, b9 {1|5}, h6 {2|6}, e9 {1|6}, f1 {2|7}, b5 {2|8}, h2 {3|6}, i3 {6|7}, b6 {2|8}, d7 {1|8}, f2 {6|8}, d8 {2|9}, f7 {5|8}, e3 {6|9}, i1 {3|7}, e8 {2|9}, i4 {3|8}, i6 {6|8}.

Naked-pair {1|5} in cells {b7, b9} contained within {rowb, box3}, updating cells {b5, b6}:

Naked-pair {2|8} in cells {b5, b6} contained within {rowb, box2}, updating cells {b7, b9}:

Naked-pair {2|9} in cells {d8, e8} contained within {col8, box6}, updating cells {d7, d9, e9, f7, f9}:

grid83
1 2 3 4 5 6 7 8 9
a 8 1 2 7 5 3 6 4 9
b 9 4 3 6
 2 
   
 8 
 2 
   
 8 
1  
 5 
   
7
1  
 5 
   
c 6 7 5 4 9 1 2 8 3
d
123
   
   
5
   
4 6
  9
 23
   
 8 
 23
  6
 8 
7
1  
   
 8 
 2 
   
  9
1  
4 6
   
e
123
   
   
  3
  6
 8 
   
  6
  9
 23
   
 8 
4 5 7
 2 
   
  9
1  
  6
   
f
 2 
   
7  
   
  6
 8 
   
4 6
7  
1
 2 
  6
 8 
9
   
 5 
 8 
3
   
456
   
g 5 2 1 9 7 4 3 6 8
h 4
  3
  6
   
8 5
 23
  6
   
 2 
  6
   
9 1 7
i
  3
   
7  
9
   
  6
7  
  3
   
 8 
1
   
  6
 8 
4 5 2

backtrack.grid83 → grid84: b5 guess 2 ∈ {2|8}

pending={b5}

deduce.grid84: naked-singles

grid84 didn't work: naked-singles ran out of candidates.

…backtrack.grid83 again

backtrack.grid83 → grid85: b5 guess 8 ∈ {2|8}

pending={b5}

deduce.grid85: naked-singles

deduce.grid85. Solved.

grid85
1 2 3 4 5 6 7 8 9
a 8 1 2 7 5 3 6 4 9
b 9 4 3 6 8 2 1 7 5
c 6 7 5 4 9 1 2 8 3
d 1 5 4 2 3 7 8 9 6
e 3 6 9 8 4 5 7 2 1
f 2 8 7 1 6 9 5 3 4
g 5 2 1 9 7 4 3 6 8
h 4 3 8 5 2 6 9 1 7
i 7 9 6 3 1 8 4 5 2

grid85. Copying solution to raw grid.